flapjack 0.7.14 → 0.7.15

data/spec/lib/flapjack/data/event_spec.rb

@@ -1,6 +1,101 @@
 require 'spec_helper'
 require 'flapjack/data/event'
 
-describe Flapjack::Data::Event, :redis => true do
+describe Flapjack::Data::Event do
+
+  let(:entity_name) { 'xyz-example.com' }
+  let(:check)       { 'ping' }
+  let(:mock_redis)  { mock(::Redis) }
+
+  let!(:time) { Time.now}
+
+  let(:event_data) { {'type'    => 'service',
+                      'state'   => 'critical',
+                      'entity'  => entity_name,
+                      'check'   => check,
+                      'time'    => time.to_i,
+                      'summary' => "timeout",
+                      'details' => "couldn't access",
+                      'acknowledgement_id' => '1234',
+                      'duration' => (60 * 60) }
+  }
+
+  context 'class' do
+
+    it "returns the next event (blocking, archiving)" do
+      mock_redis.should_receive(:brpoplpush).with('events', /^events_archive:/, 0).and_return(event_data.to_json)
+      mock_redis.should_receive(:expire)
+
+      result = Flapjack::Data::Event.next(:block => true, :archive_events => true, :redis => mock_redis)
+      result.should be_an_instance_of(Flapjack::Data::Event)
+    end
+
+    it "returns the next event (blocking, not archiving)" do
+      mock_redis.should_receive(:brpop).with('events', 0).and_return(['events', event_data.to_json])
+
+      result = Flapjack::Data::Event.next(:block => true, :archive_events => false, :redis => mock_redis)
+      result.should be_an_instance_of(Flapjack::Data::Event)
+    end
+
+    it "returns the next event (non-blocking, archiving)" do
+      mock_redis.should_receive(:rpoplpush).with('events', /^events_archive:/).and_return(event_data.to_json)
+      mock_redis.should_receive(:expire)
+
+      result = Flapjack::Data::Event.next(:block => false, :archive_events => true, :redis => mock_redis)
+      result.should be_an_instance_of(Flapjack::Data::Event)
+    end
+
+    it "returns the next event (non-blocking, not archiving)" do
+      mock_redis.should_receive(:rpop).with('events').and_return(event_data.to_json)
+
+      result = Flapjack::Data::Event.next(:block => false, :archive_events => false, :redis => mock_redis)
+      result.should be_an_instance_of(Flapjack::Data::Event)
+    end
+
+    it "handles invalid event JSON"
+
+    it "returns a count of pending events" do
+      events_len = 23
+      mock_redis.should_receive(:llen).with('events').and_return(events_len)
+
+      pc = Flapjack::Data::Event.pending_count(:redis => mock_redis)
+      pc.should == events_len
+    end
+
+    it "creates a notification testing event" do
+      Time.should_receive(:now).and_return(time)
+      mock_redis.should_receive(:rpush).with('events', /"testing"/ )
+
+      Flapjack::Data::Event.test_notifications(entity_name, check,
+        :summary => 'test', :details => 'testing', :redis => mock_redis)
+    end
+
+    it "creates an acknowledgement event" do
+      Time.should_receive(:now).and_return(time)
+      mock_redis.should_receive(:rpush).with('events', /"acking"/ )
+
+      Flapjack::Data::Event.create_acknowledgement(entity_name, check,
+        :summary => 'acking', :time => time.to_i, :redis => mock_redis)
+    end
+
+  end
+
+  context 'instance' do
+    subject { Flapjack::Data::Event.new(event_data) }
+
+    its(:entity)   { should == event_data['entity'] }
+    its(:state)    { should == event_data['state'] }
+    its(:duration) { should == event_data['duration'] }
+    its(:time)     { should == event_data['time'] }
+    its(:id)       { should == 'xyz-example.com:ping' }
+    its(:client)   { should == 'xyz' }
+    its(:type)     { should == 'service' }
+
+    it { should be_a_service }
+    it { should_not be_a_acknowledgement }
+    it { should_not be_a_test_notifications }
+    it { should_not be_ok }
+    it { should be_a_failure }
+  end
 
 end

data/spec/lib/flapjack/executive_spec.rb

@@ -19,7 +19,6 @@ describe Flapjack::Executive, :logger => true do
 
     redis = mock('redis')
 
-    #redis.should_receive(:set).with('boot_time', a_kind_of(Integer))
     redis.should_receive(:hset).with(/^executive_instance:/, "boot_time", anything)
     redis.should_receive(:hget).with('event_counters', 'all').and_return(nil)
     redis.should_receive(:hset).with('event_counters', 'all', 0)
@@ -27,17 +26,16 @@ describe Flapjack::Executive, :logger => true do
     redis.should_receive(:hset).with('event_counters', 'failure', 0)
     redis.should_receive(:hset).with('event_counters', 'action', 0)
 
-    #redis.should_receive(:zadd).with('executive_instances', a_kind_of(Integer), a_kind_of(String))
     redis.should_receive(:hset).with(/^event_counters:/, 'all', 0)
     redis.should_receive(:hset).with(/^event_counters:/, 'ok', 0)
     redis.should_receive(:hset).with(/^event_counters:/, 'failure', 0)
     redis.should_receive(:hset).with(/^event_counters:/, 'action', 0)
 
-    redis.should_receive(:expire).with(/^executive_instance:/, anything).twice
-    redis.should_receive(:expire).with(/^event_counters:/, anything).exactly(8).times
+    redis.should_receive(:expire).with(/^executive_instance:/, anything)
+    redis.should_receive(:expire).with(/^event_counters:/, anything).exactly(4).times
 
-    redis.should_receive(:hincrby).with('event_counters', 'all', 1)
-    redis.should_receive(:hincrby).with(/^event_counters:/, 'all', 1)
+    # redis.should_receive(:hincrby).with('event_counters', 'all', 1)
+    # redis.should_receive(:hincrby).with(/^event_counters:/, 'all', 1)
 
     Flapjack::Data::Event.should_receive(:pending_count).with(:redis => redis).and_return(0)
 
@@ -46,11 +44,7 @@ describe Flapjack::Executive, :logger => true do
 
     shutdown_evt = mock(Flapjack::Data::Event)
     shutdown_evt.should_receive(:inspect)
-    shutdown_evt.should_receive(:id).and_return('-:-')
-    shutdown_evt.should_receive(:type).exactly(3).times.and_return('shutdown')
-    shutdown_evt.should_receive(:state).and_return(nil)
-    shutdown_evt.should_receive(:summary).and_return(nil)
-    shutdown_evt.should_receive(:time).and_return(Time.now)
+    shutdown_evt.should_receive(:type).and_return('shutdown')
     Flapjack::Data::Event.should_receive(:next) {
       executive.instance_variable_set('@should_quit', true)
       shutdown_evt

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

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'flapjack/gateways/api/entity_check_presenter'
 
+require 'pp'
+
 describe 'Flapjack::Gateways::API::EntityCheck::Presenter' do
 
   let(:entity_check) { mock(Flapjack::Data::EntityCheck) }
@@ -53,7 +55,7 @@ describe 'Flapjack::Gateways::API::EntityCheck::Presenter' do
     # TODO check the data in those hashes
   end
 
-  it "returns the same list of outage hashes with no start and end time set" do
+  it "returns a list of outage hashes with no start and end time set" do
     entity_check.should_receive(:historical_states).
       with(nil, nil).and_return(states)
 
@@ -69,6 +71,23 @@ describe 'Flapjack::Gateways::API::EntityCheck::Presenter' do
     # 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'
+
+    entity_check.should_receive(:historical_states).
+      with(nil, nil).and_return(states)
+
+    entity_check.should_receive(:historical_state_before).
+      with(time - (4 * 60 * 60)).and_return(nil)
+
+    ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
+    outages = ecp.outages(nil, nil)
+    outages.should_not be_nil
+    outages.should be_an(Array)
+    outages.should have(3).time_ranges
+  end
+
   it "returns a (small) outage hash for a single state change" do
     entity_check.should_receive(:historical_states).
       with(nil, nil).and_return([{:state => 'critical', :timestamp => time - (4 * 60 * 60)}])
@@ -90,7 +109,7 @@ describe 'Flapjack::Gateways::API::EntityCheck::Presenter' do
       with(nil, time - (12 * 60 * 60), :scheduled => false).and_return([])
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
-    unsched_maint = ecp.unscheduled_maintenance(time - (12 * 60 * 60), time)
+    unsched_maint = ecp.unscheduled_maintenances(time - (12 * 60 * 60), time)
 
     unsched_maint.should be_an(Array)
     unsched_maint.should have(4).time_ranges
@@ -106,7 +125,7 @@ describe 'Flapjack::Gateways::API::EntityCheck::Presenter' do
       with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
-    sched_maint = ecp.scheduled_maintenance(time - (12 * 60 * 60), time)
+    sched_maint = ecp.scheduled_maintenances(time - (12 * 60 * 60), time)
 
     sched_maint.should be_an(Array)
     sched_maint.should have(4).time_ranges

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

@@ -17,7 +17,7 @@ describe 'Flapjack::Gateways::API::Entity::Presenter' do
   let(:end_time)   { time - (2 * 60 * 60) }
 
   def expect_check_presenters
-    entity.should_receive(:check_list).and_return(['ssh', 'ping'])
+    entity.should_receive(:check_list).and_return(['ping', 'ssh'])
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, 'ssh', anything).and_return(check_a)
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
@@ -29,6 +29,21 @@ describe 'Flapjack::Gateways::API::Entity::Presenter' do
       with(check_b).and_return(checkpres_b)
   end
 
+  it 'returns a list of status hashes for each check on an entity' do
+    expect_check_presenters
+
+    status_a = mock('status_a')
+    status_b = mock('status_b')
+    checkpres_a.should_receive(:status).and_return(status_a)
+    checkpres_b.should_receive(:status).and_return(status_b)
+
+    ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
+    status = ep.status
+    status.should == [{:entity => entity, :check => 'ping', :status => status_b},
+                      {:entity => entity, :check => 'ssh',  :status => status_a}]
+
+  end
+
   it "returns a list of outage hashes for each check on an entity" do
     expect_check_presenters
     outages_a = mock('outages_a')
@@ -40,38 +55,38 @@ describe 'Flapjack::Gateways::API::Entity::Presenter' do
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     outages = ep.outages(start_time, end_time)
-    outages.should == [{:check => 'ssh',  :outages => outages_a},
-                       {:check => 'ping', :outages => outages_b}]
+    outages.should == [{:entity => entity, :check => 'ping', :outages => outages_b},
+                       {:entity => entity, :check => 'ssh',  :outages => outages_a}]
   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).
+    checkpres_a.should_receive(:unscheduled_maintenances).with(start_time, end_time).
       and_return(unsched_maint_a)
-    checkpres_b.should_receive(:unscheduled_maintenance).with(start_time, end_time).
+    checkpres_b.should_receive(:unscheduled_maintenances).with(start_time, end_time).
       and_return(unsched_maint_b)
 
     ep = Flapjack::Gateways::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}]
+    unsched_maint = ep.unscheduled_maintenances(start_time, end_time)
+    unsched_maint.should == [{:entity => entity, :check => 'ping', :unscheduled_maintenances => unsched_maint_b},
+                             {:entity => entity, :check => 'ssh',  :unscheduled_maintenances => unsched_maint_a}]
   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).
+    checkpres_a.should_receive(:scheduled_maintenances).with(start_time, end_time).
       and_return(sched_maint_a)
-    checkpres_b.should_receive(:scheduled_maintenance).with(start_time, end_time).
+    checkpres_b.should_receive(:scheduled_maintenances).with(start_time, end_time).
       and_return(sched_maint_b)
 
     ep = Flapjack::Gateways::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}]
+    sched_maint = ep.scheduled_maintenances(start_time, end_time)
+    sched_maint.should == [{:entity => entity, :check => 'ping', :scheduled_maintenances => sched_maint_b},
+                           {:entity => entity, :check => 'ssh',  :scheduled_maintenances => sched_maint_a}]
   end
 
   it "returns a list of downtime for each check on an entity" do
@@ -85,8 +100,8 @@ describe 'Flapjack::Gateways::API::Entity::Presenter' do
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     downtime = ep.downtime(start_time, end_time)
-    downtime.should == [{:check => 'ssh',  :downtime => downtime_a},
-                        {:check => 'ping', :downtime => downtime_b}]
+    downtime.should == [{:entity => entity, :check => 'ping', :downtime => downtime_b},
+                        {:entity => entity, :check => 'ssh',  :downtime => downtime_a}]
   end
 
 end

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

@@ -83,88 +83,304 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     last_response.body.should == [check].to_json
   end
 
+  context 'old API calling format' do
+
+    it "returns the status for all checks on an entity" do
+      status = mock('status', :to_json => 'status!'.to_json)
+      result = {:entity => entity_name, :check => check, :status => status}
+      entity_presenter.should_receive(:status).and_return(result)
+
+      Flapjack::Gateways::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 "/status/#{entity_name_esc}"
+      last_response.should be_ok
+      last_response.body.should == ['status!'].to_json
+    end
+
+    it "should not show the status for an entity that's not found" do
+      Flapjack::Data::Entity.should_receive(:find_by_name).
+        with(entity_name, :redis => redis).and_return(nil)
+
+      get "/status/#{entity_name_esc}"
+      last_response.should be_forbidden
+    end
+
+    it "returns the status for a check on an entity" do
+      status = mock('status', :to_json => 'status!'.to_json)
+      entity_check_presenter.should_receive(:status).and_return(status)
+
+      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+        with(entity_check, :redis => redis).and_return(entity_check_presenter)
+
+      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+        with(entity, check, :redis => redis).and_return(entity_check)
+
+      Flapjack::Data::Entity.should_receive(:find_by_name).
+        with(entity_name, :redis => redis).and_return(entity)
+
+      get "/status/#{entity_name_esc}/#{check}"
+      last_response.should be_ok
+      last_response.body.should == 'status!'.to_json
+    end
+
+    it "should not show the status for a check on an entity that's not found" do
+      Flapjack::Data::Entity.should_receive(:find_by_name).
+        with(entity_name, :redis => redis).and_return(nil)
+
+      get "/status/#{entity_name_esc}/#{check}"
+      last_response.should be_forbidden
+    end
+
+    it "should not show the status for a check that's not found on an entity" do
+      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(nil)
+
+      get "/status/#{entity_name_esc}/#{check}"
+      last_response.should be_forbidden
+    end
+
+    it "returns a list of scheduled maintenance periods for an entity" do
+      sched = mock('sched', :to_json => 'sched!'.to_json)
+      result = {:entity => entity_name, :check => check, :scheduled_maintenances => sched}
+      entity_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(result)
+      Flapjack::Gateways::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 == [{:check => check, :scheduled_maintenance => sched}].to_json
+    end
+
+    it "returns a list of scheduled maintenance periods within a time window for an entity" do
+      start  = Time.parse('1 Jan 2012')
+      finish = Time.parse('6 Jan 2012')
+
+      sched = mock('sched', :to_json => 'sched!'.to_json)
+      result = {:entity => entity_name, :check => check, :scheduled_maintenances => sched}
+      entity_presenter.should_receive(:scheduled_maintenances).with(start.to_i, finish.to_i).and_return(result)
+      Flapjack::Gateways::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}?" +
+        "start_time=#{CGI.escape(start.iso8601)}&end_time=#{CGI.escape(finish.iso8601)}"
+      last_response.should be_ok
+      last_response.body.should == [{:check => check, :scheduled_maintenance => sched}].to_json
+    end
+
+    it "returns a list of scheduled maintenance periods for a check on an entity" do
+      sched = mock('sched', :to_json => 'sched!'.to_json)
+      entity_check_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(sched)
+      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+        with(entity_check, :redis => redis).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 == 'sched!'.to_json
+    end
+
+    it "creates an acknowledgement for an entity check" do
+      entity_check.should_receive(:entity_name).and_return(entity_name)
+      entity_check.should_receive(:check).and_return(check)
+
+      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)
+      Flapjack::Data::Event.should_receive(:create_acknowledgement).
+        with(entity_name, check, :summary => nil, :duration => (4 * 60 * 60), :redis => redis)
+
+      post "/acknowledgements/#{entity_name_esc}/#{check}"
+      last_response.status.should == 204
+    end
+
+    it "returns a list of unscheduled maintenance periods for an entity" do
+      unsched = mock('unsched', :to_json => 'unsched!'.to_json)
+      result = {:entity => entity_name, :check => check, :unscheduled_maintenances => unsched}
+      entity_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(result)
+      Flapjack::Gateways::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 == [{:check => check, :unscheduled_maintenance => unsched}].to_json
+    end
+
+    it "returns a list of unscheduled maintenance periods for a check on an entity" do
+      unsched = mock('unsched', :to_json => 'unsched!'.to_json)
+      entity_check_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(unsched)
+      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+        with(entity_check, :redis => redis).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 == 'unsched!'.to_json
+    end
+
+    it "returns a list of unscheduled maintenance periods within a time window for a check an entity" do
+      start    = Time.parse('1 Jan 2012')
+      finish   = Time.parse('6 Jan 2012')
+
+      unsched = mock('unsched', :to_json => 'unsched!'.to_json)
+      entity_check_presenter.should_receive(:unscheduled_maintenances).with(start.to_i, finish.to_i).and_return(unsched)
+      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+        with(entity_check, :redis => redis).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}" +
+        "?start_time=#{CGI.escape(start.iso8601)}&end_time=#{CGI.escape(finish.iso8601)}"
+      last_response.should be_ok
+      last_response.body.should == 'unsched!'.to_json
+    end
+
+    it "returns a list of outages for an entity" do
+      out = mock('out', :to_json => 'out!'.to_json)
+      result = {:entity => entity_name, :check => check, :outages => out}
+      entity_presenter.should_receive(:outages).with(nil, nil).and_return(result)
+      Flapjack::Gateways::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 == [{:check => check, :outages => out}].to_json
+    end
+
+    it "returns a list of outages for a check on an entity" do
+      out = mock('out', :to_json => 'out!'.to_json)
+      entity_check_presenter.should_receive(:outages).with(nil, nil).and_return(out)
+      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+        with(entity_check, :redis => redis).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 == 'out!'.to_json
+    end
+
+    it "returns a list of downtimes for an entity" do
+      down = mock('down', :to_json => 'down!'.to_json)
+      result = {:entity => entity_name, :check => check, :downtime => down}
+      entity_presenter.should_receive(:downtime).with(nil, nil).and_return(result)
+      Flapjack::Gateways::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 == [{:check => check, :downtime => down}].to_json
+    end
+
+    it "returns a list of downtimes for a check on an entity" do
+      down = mock('down', :to_json => 'down!'.to_json)
+      entity_check_presenter.should_receive(:downtime).with(nil, nil).and_return(down)
+      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+        with(entity_check, :redis => redis).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 == 'down!'.to_json
+    end
+
+    it "creates a test notification event for check on an entity" do
+      Flapjack::Data::Entity.should_receive(:find_by_name).
+        with(entity_name, :redis => redis).and_return(entity)
+      entity.should_receive(:name).and_return(entity_name)
+      entity_check.should_receive(:entity).and_return(entity)
+      entity_check.should_receive(:entity_name).and_return(entity_name)
+      entity_check.should_receive(:check).and_return('foo')
+      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+        with(entity, 'foo', :redis => redis).and_return(entity_check)
+
+      Flapjack::Data::Event.should_receive(:test_notifications).
+        with(entity_name, 'foo', hash_including(:redis => redis))
+
+      post "/test_notifications/#{entity_name_esc}/foo"
+      last_response.status.should == 204
+    end
+
+  end
+
   it "returns the status for all checks on an entity" do
-    entity.should_receive(:check_list).and_return([check])
+    status = mock('status')
+    result = [{:entity => entity_name, :check => check, :status => status}]
+    entity_presenter.should_receive(:status).and_return(result)
+
+    Flapjack::Gateways::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)
 
-    now = Time.now.to_i
-
-    entity_check.should_receive(:state).and_return('OK')
-    entity_check.should_receive(:summary).and_return('not bad')
-    entity_check.should_receive(:details).and_return(nil)
-    entity_check.should_receive(:in_unscheduled_maintenance?).and_return(false)
-    entity_check.should_receive(:in_scheduled_maintenance?).and_return(false)
-    entity_check.should_receive(:last_update).and_return(now - 30)
-    entity_check.should_receive(:last_problem_notification).and_return(now - 60)
-    entity_check.should_receive(:last_recovery_notification).and_return(now - 30)
-    entity_check.should_receive(:last_acknowledgement_notification).and_return(now - 45)
-    Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    get "/status/#{entity_name_esc}"
-    last_response.should be_ok
-    last_response.body.should == [{'name' => check,
-                                   'state' => 'OK',
-                                   'summary' => 'not bad',
-                                   'details' => nil,
-                                   'in_unscheduled_maintenance' => false,
-                                   'in_scheduled_maintenance' => false,
-                                   'last_update' => (now - 30),
-                                   'last_problem_notification' => (now - 60),
-                                   'last_recovery_notification' => (now - 30),
-                                   'last_acknowledgement_notification' => (now - 45)
-                                  }].to_json
+    get "/status", :entity => entity_name
+    last_response.body.should == result.to_json
   end
 
   it "should not show the status for an entity that's not found" do
     Flapjack::Data::Entity.should_receive(:find_by_name).
       with(entity_name, :redis => redis).and_return(nil)
 
-    get "/status/#{entity_name_esc}"
-    last_response.should be_not_found
+    get "/status", :entity => entity_name
+    last_response.should be_forbidden
   end
 
-  it "returns the status for a check (with non-word characters) on an entity" do
-    nw_check = "HTTP Port 443"
-    Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
+  it "returns the status for a check on an entity" do
+    status = mock('status')
+    result = [{:entity => entity_name, :check => check, :status => status}]
+    entity_check_presenter.should_receive(:status).and_return(status)
+
+    Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      with(entity_check, :redis => redis).and_return(entity_check_presenter)
 
-    now = Time.now.to_i
-
-    entity_check.should_receive(:state).and_return('OK')
-    entity_check.should_receive(:summary).and_return('not bad')
-    entity_check.should_receive(:details).and_return(nil)
-    entity_check.should_receive(:in_unscheduled_maintenance?).and_return(false)
-    entity_check.should_receive(:in_scheduled_maintenance?).and_return(false)
-    entity_check.should_receive(:last_update).and_return(now - 30)
-    entity_check.should_receive(:last_problem_notification).and_return(now - 60)
-    entity_check.should_receive(:last_recovery_notification).and_return(now - 30)
-    entity_check.should_receive(:last_acknowledgement_notification).and_return(now - 45)
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, nw_check, :redis => redis).and_return(entity_check)
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
 
-    get "/status/#{entity_name_esc}/#{URI.escape(nw_check)}"
+    get "/status", :check => {entity_name => check}
     last_response.should be_ok
-    last_response.body.should == {'name' => nw_check,
-                                  'state' => 'OK',
-                                  'summary' => 'not bad',
-                                  'details' => nil,
-                                  'in_unscheduled_maintenance' => false,
-                                  'in_scheduled_maintenance' => false,
-                                  'last_update' => (now - 30),
-                                  'last_problem_notification' => (now - 60),
-                                  'last_recovery_notification' => (now - 30),
-                                  'last_acknowledgement_notification' => (now - 45)
-                                 }.to_json
+    last_response.body.should == result.to_json
   end
 
   it "should not show the status for a check on an entity that's not found" do
     Flapjack::Data::Entity.should_receive(:find_by_name).
       with(entity_name, :redis => redis).and_return(nil)
 
-    get "/status/#{entity_name_esc}/#{check}"
-    last_response.should be_not_found
+    get "/status", :check => {entity_name => check}
+    last_response.should be_forbidden
   end
 
   it "should not show the status for a check that's not found on an entity" do
@@ -174,37 +390,41 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, check, :redis => redis).and_return(nil)
 
-    get "/status/#{entity_name_esc}/#{check}"
-    last_response.should be_not_found
+    get "/status", :check => {entity_name => check}
+    last_response.should be_forbidden
   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::Gateways::API::EntityPresenter.should_receive(:new).
-      with(entity, :redis => redis).and_return(entity_presenter)
+  it "creates an acknowledgement for an entity check" do
     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}"
-    last_response.should be_ok
-    last_response.body.should == result_json
+    entity_check.should_receive(:entity_name).and_return(entity_name)
+    entity_check.should_receive(:check).and_return(check)
+
+    Flapjack::Data::Event.should_receive(:create_acknowledgement).
+      with(entity_name, check, :summary => nil, :duration => (4 * 60 * 60), :redis => redis)
+
+    post '/acknowledgements',:check => {entity_name => check}
+    last_response.status.should == 204
   end
 
-  it "creates an acknowledgement for an entity check" do
-    Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
+  it "deletes an unscheduled maintenance period for an entity check" do
+    end_time = Time.now + (60 * 60) # an hour from now
+    entity_check.should_receive(:end_unscheduled_maintenance).with(:end_time => end_time.to_i)
+
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, check, :redis => redis).and_return(entity_check)
-    entity_check.should_receive(:create_acknowledgement).with('summary' => nil, 'duration' => (4 * 60 * 60))
 
-    post "/acknowledgements/#{entity_name_esc}/#{check}"
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    delete "/unscheduled_maintenances", :check => {entity_name => check}, :end_time => end_time.iso8601
     last_response.status.should == 204
   end
 
-  it "creates a scheduled maintenance for an entity check" do
+  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
     Flapjack::Data::Entity.should_receive(:find_by_name).
@@ -219,169 +439,308 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     last_response.status.should == 204
   end
 
+  it "deletes a scheduled maintenance period for an entity check" do
+    start_time = Time.now + (60 * 60) # an hour from now
+    entity_check.should_receive(:delete_scheduled_maintenance).with(:start_time => start_time.to_i)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    delete "/scheduled_maintenances", :check => {entity_name => check}, :start_time => start_time.iso8601
+    last_response.status.should == 204
+  end
+
+  it "deletes scheduled maintenance periods for multiple entity checks" do
+    start_time = Time.now + (60 * 60) # an hour from now
+
+    entity_check_2 = mock(Flapjack::Data::EntityCheck)
+
+    entity_check.should_receive(:delete_scheduled_maintenance).with(:start_time => start_time.to_i)
+    entity_check_2.should_receive(:delete_scheduled_maintenance).with(:start_time => start_time.to_i)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'foo', :redis => redis).and_return(entity_check_2)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    delete "/scheduled_maintenances", :check => {entity_name => [check, 'foo']}, :start_time => start_time.iso8601
+    last_response.status.should == 204
+  end
+
+  it "returns a list of scheduled maintenance periods for an entity" do
+    sm = mock('sched_maint')
+    result = [{:entity => entity_name, :check => check, :scheduled_maintenances => sm}]
+
+    entity_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(result)
+
+    Flapjack::Gateways::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 => entity_name
+    last_response.should be_ok
+    last_response.body.should == result.to_json
+  end
+
   it "returns a list of scheduled maintenance periods within a time window for an entity" do
     start  = Time.parse('1 Jan 2012')
     finish = Time.parse('6 Jan 2012')
 
-    result = mock('result')
-    result_json = %q{"result"}
-    result.should_receive(:to_json).and_return(result_json)
-    entity_presenter.should_receive(:scheduled_maintenance).with(start.to_i, finish.to_i).and_return(result)
+    sm = mock('sched_maint')
+    result = [{:entity => entity_name, :check => check, :scheduled_maintenances => sm}]
+
+    entity_presenter.should_receive(:scheduled_maintenances).with(start.to_i, finish.to_i).and_return(result)
+
     Flapjack::Gateways::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}?" +
-      "start_time=#{CGI.escape(start.iso8601)}&end_time=#{CGI.escape(finish.iso8601)}"
+    get "/scheduled_maintenances", :entity => entity_name,
+      :start_time => start.iso8601, :end_time => finish.iso8601
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_json
   end
 
   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)
+    sm = mock('sched_maint')
+    result = [{:entity => entity_name, :check => check, :scheduled_maintenances => sm}]
+
+    entity_check_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(sm)
+
     Flapjack::Gateways::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)
+      with(entity_check, :redis => redis).and_return(entity_check_presenter)
+
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, check, :redis => redis).and_return(entity_check)
 
-    get "/scheduled_maintenances/#{entity_name_esc}/#{check}"
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/scheduled_maintenances", :check => {entity_name => check}
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_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)
+    um = mock('unsched_maint')
+    result = [{:entity => entity_name, :check => check, :unscheduled_maintenances => um}]
+
+    entity_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(result)
+
     Flapjack::Gateways::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}"
+    get "/unscheduled_maintenances", :entity => entity_name
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_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)
+    um = mock('unsched_maint')
+    result = [{:entity => entity_name, :check => check, :unscheduled_maintenances => um}]
+
+    entity_check_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(um)
+
     Flapjack::Gateways::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)
+      with(entity_check, :redis => redis).and_return(entity_check_presenter)
+
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, check, :redis => redis).and_return(entity_check)
 
-    get "/unscheduled_maintenances/#{entity_name_esc}/#{check}"
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/unscheduled_maintenances", :check => {entity_name => check}
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_json
   end
 
   it "returns a list of unscheduled maintenance periods within a time window for a check an entity" do
-    start    = Time.parse('1 Jan 2012')
-    finish   = Time.parse('6 Jan 2012')
+    start  = Time.parse('1 Jan 2012')
+    finish = Time.parse('6 Jan 2012')
+
+    um = mock('unsched_maint')
+    result = [{:entity => entity_name, :check => check, :unscheduled_maintenances => um}]
+
+    entity_check_presenter.should_receive(:unscheduled_maintenances).with(start.to_i, finish.to_i).and_return(um)
 
-    result = mock('result')
-    result_json = %q{"result"}
-    result.should_receive(:to_json).and_return(result_json)
-    entity_check_presenter.should_receive(:unscheduled_maintenance).with(start.to_i, finish.to_i).and_return(result)
     Flapjack::Gateways::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)
+      with(entity_check, :redis => redis).and_return(entity_check_presenter)
+
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, check, :redis => redis).and_return(entity_check)
 
-    get "/unscheduled_maintenances/#{entity_name_esc}/#{check}" +
-      "?start_time=#{CGI.escape(start.iso8601)}&end_time=#{CGI.escape(finish.iso8601)}"
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/unscheduled_maintenances", :check => {entity_name => check},
+      :start_time => start.iso8601, :end_time => finish.iso8601
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_json
   end
 
-  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)
+  it "returns a list of outages, for one whole entity and two checks on another entity" do
+    outages_1 = mock('outages_1')
+    outages_2 = mock('outages_2')
+    outages_3 = mock('outages_3')
+
+    entity_2_name = 'entity_2'
+    entity_2 = mock(Flapjack::Data::Entity)
+
+    result = [{:entity => entity_name,   :check => check, :outages => outages_1},
+              {:entity => entity_2_name, :check => 'foo', :outages => outages_2},
+              {:entity => entity_2_name, :check => 'bar', :outages => outages_3}]
+
+    foo_check = mock(Flapjack::Data::EntityCheck)
+    bar_check = mock(Flapjack::Data::EntityCheck)
+
+    foo_check_presenter = mock(Flapjack::Gateways::API::EntityCheckPresenter)
+    bar_check_presenter = mock(Flapjack::Gateways::API::EntityCheckPresenter)
+
+    entity_presenter.should_receive(:outages).with(nil, nil).and_return(result[0])
+    foo_check_presenter.should_receive(:outages).with(nil, nil).and_return(outages_2)
+    bar_check_presenter.should_receive(:outages).with(nil, nil).and_return(outages_3)
+
     Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
       with(entity, :redis => redis).and_return(entity_presenter)
+
+    Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      with(foo_check, :redis => redis).and_return(foo_check_presenter)
+    Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      with(bar_check, :redis => redis).and_return(bar_check_presenter)
+
     Flapjack::Data::Entity.should_receive(:find_by_name).
       with(entity_name, :redis => redis).and_return(entity)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_2_name, :redis => redis).and_return(entity_2)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity_2, 'foo', :redis => redis).and_return(foo_check)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity_2, 'bar', :redis => redis).and_return(bar_check)
 
-    get "/outages/#{entity_name_esc}"
+    get "/outages", :entity => entity_name, :check => {entity_2_name => ['foo', 'bar']}
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_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)
+    outages = mock('outages')
+    result = [{:entity => entity_name, :check => check, :outages => outages}]
+
+    entity_check_presenter.should_receive(:outages).with(nil, nil).and_return(outages)
+
     Flapjack::Gateways::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)
+      with(entity_check, :redis => redis).and_return(entity_check_presenter)
+
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, check, :redis => redis).and_return(entity_check)
 
-    get "/outages/#{entity_name_esc}/#{check}"
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/outages", :check => {entity_name => check}
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_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)
+    downtime = mock('downtime')
+    result = [{:entity => entity_name, :check => check, :downtime => downtime}]
+
     entity_presenter.should_receive(:downtime).with(nil, nil).and_return(result)
+
     Flapjack::Gateways::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}"
+    get "/downtime", :entity => entity_name
     last_response.should be_ok
-    last_response.body.should == result_json
+    last_response.body.should == result.to_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)
+    downtime = mock('downtime')
+    result = [{:entity => entity_name, :check => check, :downtime => downtime}]
+
+    entity_check_presenter.should_receive(:downtime).with(nil, nil).and_return(downtime)
+
     Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
-      with(entity_check).and_return(entity_check_presenter)
+      with(entity_check, :redis => redis).and_return(entity_check_presenter)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/downtime", :check => {entity_name => check}
+    last_response.should be_ok
+    last_response.body.should == result.to_json
+  end
+
+  it "creates test notification events for all checks on an entity" do
+    entity.should_receive(:check_list).and_return([check, 'foo'])
+    entity.should_receive(:name).twice.and_return(entity_name)
     Flapjack::Data::Entity.should_receive(:find_by_name).
       with(entity_name, :redis => redis).and_return(entity)
+
+    entity_check.should_receive(:entity).and_return(entity)
+    entity_check.should_receive(:entity_name).and_return(entity_name)
+    entity_check.should_receive(:check).and_return(check)
+
     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
+    entity_check_2 = mock(Flapjack::Data::EntityCheck)
+    entity_check_2.should_receive(:entity).and_return(entity)
+    entity_check_2.should_receive(:entity_name).and_return(entity_name)
+    entity_check_2.should_receive(:check).and_return('foo')
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'foo', :redis => redis).and_return(entity_check_2)
+
+    Flapjack::Data::Event.should_receive(:test_notifications).
+      with(entity_name, check, hash_including(:redis => redis))
+
+    Flapjack::Data::Event.should_receive(:test_notifications).
+      with(entity_name, 'foo', hash_including(:redis => redis))
+
+
+    post '/test_notifications', :entity => entity_name
+    last_response.status.should == 204
   end
 
   it "creates a test notification event for check on an entity" do
-
     Flapjack::Data::Entity.should_receive(:find_by_name).
       with(entity_name, :redis => redis).and_return(entity)
     entity.should_receive(:name).and_return(entity_name)
+    entity_check.should_receive(:entity).and_return(entity)
+    entity_check.should_receive(:entity_name).and_return(entity_name)
+    entity_check.should_receive(:check).and_return(check)
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'foo', :redis => redis).and_return(entity_check)
-    entity_check.should_receive(:test_notifications)
+      with(entity, check, :redis => redis).and_return(entity_check)
+  
+    Flapjack::Data::Event.should_receive(:test_notifications).
+    with(entity_name, check, hash_including(:redis => redis))
+
 
-    post "/test_notifications/#{entity_name_esc}/foo"
+    post '/test_notifications', :check => {entity_name => check}
     last_response.status.should == 204
   end
 
@@ -556,7 +915,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "lists a contact's notification rules" do
@@ -579,7 +938,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/notification_rules"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "returns a specified notification rule" do
@@ -597,7 +956,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/notification_rules/#{notification_rule.id}"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # POST /notification_rules
@@ -627,7 +986,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
     post "/notification_rules", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "does not create a notification_rule if a rule id is provided" do
@@ -665,7 +1024,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/notification_rules/#{notification_rule.id}", notification_rule_data
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "does not update a notification_rule for a contact that's not present" do
@@ -676,7 +1035,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
     put "/notification_rules/#{notification_rule.id}", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # DELETE /notification_rules/RULE_ID
@@ -697,7 +1056,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/notification_rules/#{notification_rule.id}"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "does not delete a notification rule if the contact is not present" do
@@ -708,7 +1067,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/notification_rules/#{notification_rule.id}"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # GET /contacts/CONTACT_ID/media
@@ -732,12 +1091,12 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/media"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # GET /contacts/CONTACT_ID/media/MEDIA
   it "returns the specified media of a contact" do
-    contact.should_receive(:media).twice.and_return(media)
+    contact.should_receive(:media).and_return(media)
     contact.should_receive(:media_intervals).and_return(media_intervals)
     Flapjack::Data::Contact.should_receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
@@ -754,7 +1113,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/media/sms"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "does not return the media of a contact if the media is not present" do
@@ -763,7 +1122,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "/contacts/#{contact.id}/media/telepathy"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # PUT, DELETE /contacts/CONTACT_ID/media/MEDIA
@@ -792,7 +1151,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/contacts/#{contact.id}/media/sms", {:address => '04987654321', :interval => '200'}
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "does not create a media of a contact if no address is provided" do
@@ -803,12 +1162,19 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     last_response.should be_forbidden
   end
 
-  it "does not create a media of a contact if no interval is provided" do
+  it "creates a media of a contact even if no interval is provided" do
+    alt_media = media.merge('sms' => '04987654321')
+    alt_media_intervals = media_intervals.merge('sms' => nil)
+
+    contact.should_receive(:set_address_for_media).with('sms', '04987654321')
+    contact.should_receive(:set_interval_for_media).with('sms', nil)
+    contact.should_receive(:media).and_return(alt_media)
+    contact.should_receive(:media_intervals).and_return(alt_media_intervals)
     Flapjack::Data::Contact.should_receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     put "/contacts/#{contact.id}/media/sms", {:address => '04987654321'}
-    last_response.should be_forbidden
+    last_response.should be_ok
   end
 
   it "deletes a media of a contact" do
@@ -825,7 +1191,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/contacts/#{contact.id}/media/sms"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # GET /contacts/CONTACT_ID/timezone
@@ -844,7 +1210,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/timezone"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # PUT /contacts/CONTACT_ID/timezone
@@ -863,7 +1229,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   # DELETE /contacts/CONTACT_ID/timezone
@@ -881,7 +1247,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/contacts/#{contact.id}/timezone"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
 
@@ -902,7 +1268,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(entity_name, :redis => redis).and_return(nil)
 
     post "entities/#{entity_name}/tags", :tag => 'web'
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "sets multiple tags on an entity and returns current tags" do
@@ -922,7 +1288,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(entity_name, :redis => redis).and_return(nil)
 
     post "entities/#{entity_name}/tags", :tag => ['web', 'app']
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "removes a single tag from an entity" do
@@ -939,7 +1305,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(entity_name, :redis => redis).and_return(nil)
 
     delete "entities/#{entity_name}/tags", :tag => 'web'
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "removes multiple tags from an entity" do
@@ -956,7 +1322,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(entity_name, :redis => redis).and_return(nil)
 
     delete "entities/#{entity_name}/tags", :tag => ['web', 'app']
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "gets all tags on an entity" do
@@ -974,7 +1340,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(entity_name, :redis => redis).and_return(nil)
 
     get "entities/#{entity_name}/tags"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
 
@@ -994,7 +1360,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     post "contacts/#{contact.id}/tags", :tag => 'web'
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "sets multiple tags on a contact and returns current tags" do
@@ -1013,7 +1379,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     post "contacts/#{contact.id}/tags", :tag => ['web', 'app']
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "removes a single tag from a contact" do
@@ -1030,7 +1396,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "contacts/#{contact.id}/tags", :tag => 'web'
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "removes multiple tags from a contact" do
@@ -1047,7 +1413,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "contacts/#{contact.id}/tags", :tag => ['web', 'app']
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "gets all tags on a contact" do
@@ -1065,7 +1431,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "contacts/#{contact.id}/tags"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "gets all entity tags for a contact" do
@@ -1093,7 +1459,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "contacts/#{contact.id}/entity_tags"
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "adds tags to multiple entities for a contact" do
@@ -1127,7 +1493,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
     post "contacts/#{contact.id}/entity_tags",
       :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
   it "deletes tags from multiple entities for a contact" do
@@ -1155,7 +1521,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
     delete "contacts/#{contact.id}/entity_tags",
       :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
-    last_response.should be_not_found
+    last_response.should be_forbidden
   end
 
 end