flapjack 1.6.0 → 2.0.0b1

data/features/notifications.feature

@@ -5,71 +5,79 @@ Feature: notifications
 
   # TODO test across multiple contacts
 
-  Scenario: Queue an SMS notification
-    Given the user wants to receive SMS notifications for entity 'example.com'
-    When an event notification is generated for entity 'example.com'
-    Then an SMS notification for entity 'example.com' should be queued for the user
-    And an email notification for entity 'example.com' should not be queued for the user
+  Scenario: Queue an SMS alert
+    Given the user wants to receive SMS alerts for check 'example.com:PING'
+    When an event notification is generated for check 'example.com:PING'
+    Then an SMS alert for check 'example.com:PING' should be queued
+    And an email alert for check 'example.com:PING' should not be queued
 
-  Scenario: Queue a Nexmo SMS notification
-    Given the user wants to receive Nexmo SMS notifications for entity 'example.com'
-    When an event notification is generated for entity 'example.com'
-    Then a Nexmo SMS notification for entity 'example.com' should be queued for the user
-    And an email notification for entity 'example.com' should not be queued for the user
-    And an SMS notification for entity 'example.com' should not be queued for the user
+  Scenario: Queue a Nexmo alert
+    Given the user wants to receive Nexmo alerts for check 'example.com:PING'
+    When an event notification is generated for check 'example.com:PING'
+    Then a Nexmo alert for check 'example.com:PING' should be queued
+    And an email alert for check 'example.com:PING' should not be queued
+    And an SMS alert for check 'example.com:PING' should not be queued
 
-  Scenario: Queue an SNS notification
-    Given the user wants to receive SNS notifications for entity 'example.com'
-    When an event notification is generated for entity 'example.com'
-    Then an SNS notification for entity 'example.com' should be queued for the user
-    And an email notification for entity 'example.com' should not be queued for the user
+  Scenario: Queue an SNS alert
+    Given the user wants to receive SNS alerts for check 'example.com:PING'
+    When an event notification is generated for check 'example.com:PING'
+    Then an SNS alert for check 'example.com:PING' should be queued
+    And an email alert for check 'example.com:PING' should not be queued
 
-  Scenario: Queue an email notification
-    Given the user wants to receive email notifications for entity 'example.com'
-    When an event notification is generated for entity 'example.com'
-    Then an email notification for entity 'example.com' should be queued for the user
-    And an SMS notification for entity 'example.com' should not be queued for the user
+  Scenario: Queue an email alert
+    Given the user wants to receive email alerts for check 'example.com:PING'
+    When an event notification is generated for check 'example.com:PING'
+    Then an email alert for check 'example.com:PING' should be queued
+    And an SMS alert for check 'example.com:PING' should not be queued
 
-  Scenario: Queue SMS and email notifications
-    Given the user wants to receive SMS notifications for entity 'example.com' and email notifications for entity 'example2.com'
-    When an event notification is generated for entity 'example.com'
-    And an event notification is generated for entity 'example2.com'
-    Then an SMS notification for entity 'example.com' should be queued for the user
-    And an SMS notification for entity 'example2.com' should not be queued for the user
-    Then an email notification for entity 'example.com' should not be queued for the user
-    And an email notification for entity 'example2.com' should be queued for the user
+  Scenario: Queue SMS and email alerts
+    Given a user wants to receive SMS alerts for check 'example.com:PING'
+    And a user wants to receive email alerts for check 'example2.com:SSH'
+    When an event notification is generated for check 'example.com:PING'
+    And an event notification is generated for check 'example2.com:SSH'
+    Then an SMS alert for check 'example.com:PING' should be queued
+    And an SMS alert for check 'example2.com:SSH' should not be queued
+    Then an email alert for check 'example.com:PING' should not be queued
+    And an email alert for check 'example2.com:SSH' should be queued
 
-  Scenario: Send a queued SMS notification
-    Given a user SMS notification has been queued for entity 'example.com'
-    When the SMS notification handler runs successfully
-    Then the user should receive an SMS notification
+  Scenario: Send a queued SMS alert
+    Given a user wants to receive SMS alerts for check 'example.com:PING'
+    And an SMS alert has been queued for check 'example.com:PING'
+    When the SMS alert handler runs successfully
+    Then the user should receive an SMS alert
 
-  Scenario: Send a queued Nexmo SMS notification
-    Given a user Nexmo SMS notification has been queued for entity 'example.com'
-    When the Nexmo SMS notification handler runs successfully
-    Then the user should receive an Nexmo SMS notification
+  Scenario: Send a queued Nexmo alert
+    Given a user wants to receive Nexmo alerts for check 'example.com:PING'
+    And a Nexmo alert has been queued for check 'example.com:PING'
+    When the Nexmo alert handler runs successfully
+    Then the user should receive a Nexmo alert
 
-  Scenario: Send a queued SNS notification
-    Given a user SNS notification has been queued for entity 'example.com'
-    When the SNS notification handler runs successfully
-    Then the user should receive an SNS notification
+  Scenario: Send a queued SNS alert
+    Given a user wants to receive SNS alerts for check 'example.com:PING'
+    And an SNS alert has been queued for check 'example.com:PING'
+    When the SNS alert handler runs successfully
+    Then the user should receive an SNS alert
 
-  Scenario: Handle a failure to send a queued SMS notification
-    Given a user SMS notification has been queued for entity 'example.com'
-    When the SMS notification handler fails to send an SMS
-    Then the user should not receive an SMS notification
+  Scenario: Handle a failure to send a queued SMS alert
+    Given a user wants to receive SMS alerts for check 'example.com:PING'
+    And an SMS alert has been queued for check 'example.com:PING'
+    When the SMS alert handler fails to send an SMS
+    Then the user should not receive an SMS alert
 
-  Scenario: Handle a failure to send a queued SNS notification
-    Given a user SNS notification has been queued for entity 'example.com'
-    When the SNS notification handler fails to send an SMS
-    Then the user should not receive an SNS notification
+  Scenario: Handle a failure to send a queued SNS alert
+    Given a user wants to receive SNS alerts for check 'example.com:PING'
+    And an SNS alert has been queued for check 'example.com:PING'
+    When the SNS alert handler fails to send an SMS
+    Then the user should not receive an SNS alert
 
-  Scenario: Send a queued email notification
-    Given a user email notification has been queued for entity 'example.com'
-    When the email notification handler runs successfully
-    Then the user should receive an email notification
+  Scenario: Send a queued email alert
+    Given a user wants to receive email alerts for check 'example.com:PING'
+    And an email alert has been queued for check 'example.com:PING'
+    When the email alert handler runs successfully
+    Then the user should receive an email alert
 
-  Scenario: Handle a failure to send a queued email notification
-    Given a user email notification has been queued for entity 'example.com'
-    When the email notification handler fails to send an email
-    Then the user should not receive an email notification
+  Scenario: Handle a failure to send a queued email alert
+    Given a user wants to receive email alerts for check 'example.com:PING'
+    And an email alert has been queued for check 'example.com:PING'
+    When the email alert handler fails to send an email
+    Then the user should not receive an email alert

data/features/rollup.feature

@@ -1,27 +1,27 @@
-@rollup @notification_rules @processor @notifier @events
+@rollup @notification_rules @resque @processor @notifier @events
 Feature: Rollup on a per contact, per media basis
 
   Background:
-    Given the following users exist:
-      | id  | first_name | last_name | email             | sms          | timezone         |
-      | 1   | Malak      | Al-Musawi | malak@example.com | +61400000001 | Asia/Baghdad     |
+    Given the following contacts exist:
+      | id                                   | name            | timezone     |
+      | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | Malak Al-Musawi | Asia/Baghdad |
 
-    And the following entities exist:
-      | id  | name           | contacts |
-      | 1   | foo            | 1        |
-      | 2   | baz            | 1        |
+    And the following media exist:
+      | id                                   | contact_id                           | transport | address           | interval | rollup_threshold |
+      | 28032dbf-388d-4f52-91b2-dc5e5be2becc | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | email     | malak@example.com | 15       | 1                |
+      | 73e2803f-948e-467a-a707-37b9f53ee21a | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | sms       | +61400000001      | 15       | 2                |
 
-    And user 1 has the following notification intervals:
-      | email | sms |
-      | 15    | 15  |
+    And the following checks exist:
+      | id                                   | name     | tags     |
+      | 56c13ce2-f246-4bc6-adfa-2206789c3ced | foo:ping | foo,ping |
+      | d1a39575-0480-4f65-a7f7-64c90db93731 | baz:ping | baz,ping |
 
-    And user 1 has the following notification rollup thresholds:
-      | email | sms |
-      | 1     | 2   |
-
-    And user 1 has the following notification rules:
-      | entities | unknown_media | warning_media | critical_media   |
-      |          |               | email         | sms,email        |
+    And the following rules exist:
+      | id                                   | contact_id                           | blackhole | strategy | tags     | condition | time_restriction | media_ids                                                                 |
+      | b0c8deb9-b8c8-4fdd-acc4-72493852ca15 | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | false     | all_tags | foo,ping | critical  |                   | 28032dbf-388d-4f52-91b2-dc5e5be2becc,73e2803f-948e-467a-a707-37b9f53ee21a |
+      | b18e9f48-59e7-4c25-b94c-d4ebd4a6559a | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | false     | all_tags | foo,ping | warning   |                   | 28032dbf-388d-4f52-91b2-dc5e5be2becc                                      |
+      | 2df6bbc4-d6a4-4f23-b6e5-5c4a07c6e686 | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | false     | all_tags | baz,ping | critical  |                   | 28032dbf-388d-4f52-91b2-dc5e5be2becc,73e2803f-948e-467a-a707-37b9f53ee21a |
+      | f163bf33-b53e-4138-ab27-1dd89f2d6fdd | 7f96a216-76aa-45fc-a88e-7431cd6d7aac | false     | all_tags | baz,ping | warning   |                   | 28032dbf-388d-4f52-91b2-dc5e5be2becc                                      |
 
   @time
   Scenario: Rollup threshold of 1 means first alert is a rollup
@@ -140,7 +140,8 @@ Feature: Rollup on a per contact, per media basis
   Scenario: Unscheduled maintenance ending promotes rollup
     Given check 'ping' for entity 'foo' is in unscheduled maintenance
     And   check 'ping' for entity 'baz' is in an ok state
-    When  a critical event is received for check 'ping' on entity 'foo'
+    When  1 minute passes
+    And   a critical event is received for check 'ping' on entity 'foo'
     And   1 minute passes
     And   a critical event is received for check 'ping' on entity 'foo'
     Then  0 sms alerts should be queued for +61400000001
@@ -155,26 +156,6 @@ Feature: Rollup on a per contact, per media basis
     Then  1 sms alert of type problem and rollup problem should be queued for +61400000001
     And   2 sms alerts should be queued for +61400000001
 
-  @time
-  Scenario: Scheduled maintenance ending promotes rollup
-    Given check 'ping' for entity 'foo' is in an ok state
-    Given check 'ping' for entity 'foo' is in scheduled maintenance for 4 hours
-    And   check 'ping' for entity 'baz' is in an ok state
-    When  a critical event is received for check 'ping' on entity 'foo'
-    And   1 minute passes
-    And   a critical event is received for check 'ping' on entity 'foo'
-    Then  0 sms alerts should be queued for +61400000001
-    When  5 minutes passes
-    And   a critical event is received for check 'ping' on entity 'baz'
-    And   1 minute passes
-    And   a critical event is received for check 'ping' on entity 'baz'
-    Then  1 sms alert of type problem and rollup none should be queued for +61400000001
-    And   1 sms alerts should be queued for +61400000001
-    When  4 hours passes
-    And   a critical event is received for check 'ping' on entity 'foo'
-    Then  2 sms alerts should be queued for +61400000001
-    And   1 sms alert of type problem and rollup problem should be queued for +61400000001
-
   @time
   Scenario: Disabling a failing check suppresses rollup
     Given check 'ping' for entity 'foo' is in an ok state
@@ -209,20 +190,38 @@ Feature: Rollup on a per contact, per media basis
     And   a critical event is received for check 'ping' on entity 'baz'
     And   1 minute passes
     And   a critical event is received for check 'ping' on entity 'baz'
-    Then  2 sms alerts should be queued for +61400000001
+    Then  1 sms alerts should be queued for +61400000001
     Then  1 sms alert of type problem and rollup none should be queued for +61400000001
-    Then  1 sms alert of type problem and rollup recovery should be queued for +61400000001
     When  1 hour passes
     And   check 'ping' on entity 'foo' is enabled
     And   5 minutes passes
     And   a critical event is received for check 'ping' on entity 'foo'
-    Then  3 sms alerts should be queued for +61400000001
+    Then  2 sms alerts should be queued for +61400000001
     Then  1 sms alert of type problem and rollup none should be queued for +61400000001
-    Then  1 sms alert of type problem and rollup recovery should be queued for +61400000001
     And   1 sms alert of type problem and rollup problem should be queued for +61400000001
 
   @time
-  Scenario: Contact ceases to be a contact on an entity that they were being alerted for
+  Scenario: Scheduled maintenance ending promotes rollup
+    Given check 'ping' for entity 'foo' is in an ok state
+    Given check 'ping' for entity 'foo' is in scheduled maintenance for 4 hours
+    And   check 'ping' for entity 'baz' is in an ok state
+    When  a critical event is received for check 'ping' on entity 'foo'
+    And   1 minute passes
+    And   a critical event is received for check 'ping' on entity 'foo'
+    Then  0 sms alerts should be queued for +61400000001
+    When  5 minutes passes
+    And   a critical event is received for check 'ping' on entity 'baz'
+    And   1 minute passes
+    And   a critical event is received for check 'ping' on entity 'baz'
+    Then  1 sms alert of type problem and rollup none should be queued for +61400000001
+    And   1 sms alerts should be queued for +61400000001
+    When  4 hours passes
+    And   a critical event is received for check 'ping' on entity 'foo'
+    Then  2 sms alerts should be queued for +61400000001
+    And   1 sms alert of type problem and rollup problem should be queued for +61400000001
+
+  @time
+  Scenario: Contact removes a rule matching on a check
     Given check 'ping' for entity 'foo' is in an ok state
     And   check 'ping' for entity 'baz' is in an ok state
     When  a critical event is received for check 'ping' on entity 'foo'
@@ -237,7 +236,7 @@ Feature: Rollup on a per contact, per media basis
     And   1 sms alerts of type problem and rollup none should be queued for +61400000001
     And   2 sms alerts should be queued for +61400000001
     When  20 minute passes
-    And   user 1 ceases to be a contact of entity 'foo'
+    And   the rule with id 'b0c8deb9-b8c8-4fdd-acc4-72493852ca15' is removed
     And   a critical event is received for check 'ping' on entity 'baz'
     Then  1 sms alert of rollup recovery should be queued for +61400000001
 
@@ -249,9 +248,8 @@ Feature: Rollup on a per contact, per media basis
     And   1 minute passes
     And   a critical event is received for check 'ping' on entity 'foo'
     Then  1 sms alert of type problem and rollup none should be queued for +61400000001
-    And   1 sms alert should be queued for +61400000001
     When  1 minute passes
-    And   a test event is received for check 'sausage' on entity 'foo'
+    And   a test event is received for check 'ping' on entity 'foo'
     Then  1 sms alert of type problem and rollup none should be queued for +61400000001
     And   1 sms alert of type test and rollup none should be queued for +61400000001
     And   2 sms alerts should be queued for +61400000001

data/features/steps/cli_steps.rb

@@ -11,20 +11,19 @@ Given /^a fifo named "([^"]*)" exists$/ do |fifo_name|
   create_fifo(fifo_name)
 end
 
-When /^I ((?:re)?start|stop) (\S+)( \(daemonised\))?( \(via bundle exec\))? with `(.+)`$/ do |start_stop_restart, exe, daemonise, bundle_exec, cmd|
+When /^I ((?:re)?start|stop) (\S+)( \(via bundle exec\))? with `(.+)`$/ do |start_stop_restart, exe,  bundle_exec, cmd|
   @daemons_output      ||= []
   @daemons_exit_status ||= []
 
   @root = Pathname.new(File.dirname(__FILE__)).parent.parent.expand_path
   command = "#{bundle_exec ? 'bundle exec ' : ''}#{@root.join('bin')}/#{cmd}"
 
-  # enable debugging output from spawn_process etc
-  #@debug = true
+  # # enable debugging output from spawn_process etc
+  # @debug = true
 
   case start_stop_restart
   when 'start'
-    @process_h = spawn_process(command,
-                  :daemon_pidfile => (daemonise.nil? || daemonise.empty?) ? nil : "tmp/cucumber_cli/#{exe}.pid")
+    @process_h = spawn_process(command)
   when 'stop', 'restart'
     @daemons_output << `#{command}`
     @daemons_exit_status << $?

data/features/steps/events_steps.rb

@@ -1,466 +1,256 @@
 #!/usr/bin/env ruby
 
 def drain_events
-  loop do
-    event = Flapjack::Data::Event.next('events', :block => false,
-      :redis => @redis)
-    break unless event
+  @processor.send(:foreach_on_queue, 'events') do |event|
     @processor.send(:process_event, event)
   end
   drain_notifications
 end
 
 def drain_notifications
-  return unless @notifier_redis
-  loop do
-    notification = Flapjack::Data::Notification.next('notifications',
-      :block => false, :redis => @notifier_redis)
-    break unless notification
+  return unless @notifier
+  @notifier.instance_variable_get('@queue').send(:foreach) do |notification|
     @notifier.send(:process_notification, notification)
   end
 end
 
-def drain_alerts(queue, gateway)
-  return unless @notifier_redis
-  loop do
-    alert = Flapjack::Data::Alert.next(queue, :block => false,
-      :redis => @notifier_redis, :logger => @logger)
-    break unless alert
-    gateway.send(:deliver, alert)
-  end
-end
+def set_scheduled_maintenance(entity_name, check_name, duration)
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-def submit_event(event)
-  @redis.rpush('events', Flapjack.dump_json(event))
+  t = Time.now
+  sched_maint = Flapjack::Data::ScheduledMaintenance.new(:start_time => Time.at(t.to_i - 60),
+    :end_time => Time.at(t.to_i + duration), :summary => 'upgrading everything')
+  expect(sched_maint.save).to be true
+  check.scheduled_maintenances << sched_maint
 end
 
-def set_scheduled_maintenance(entity, check, duration)
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  t = Time.now.to_i
-  entity_check.create_scheduled_maintenance(t, duration, :summary => "upgrading everything")
-  @redis.setex("#{entity}:#{check}:scheduled_maintenance", duration, t)
-end
+def remove_scheduled_maintenance(entity_name, check_name)
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-def remove_scheduled_maintenance(entity, check)
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  sm = entity_check.maintenances(nil, nil, :scheduled => true)
-  sm.each do |m|
-    entity_check.end_scheduled_maintenance(m[:start_time])
+  t = Time.now
+  check.scheduled_maintenances.each do |sm|
+    check.end_scheduled_maintenance(sm, t)
+    sched_maint.destroy
   end
 end
 
-def remove_unscheduled_maintenance(entity, check)
-  # end any unscheduled downtime
-  event_id = entity + ":" + check
-  if (um_start = @redis.get("#{event_id}:unscheduled_maintenance"))
-    @redis.del("#{event_id}:unscheduled_maintenance")
-    duration = Time.now.to_i - um_start.to_i
-    @redis.zadd("#{event_id}:unscheduled_maintenances", duration, um_start)
-  end
-end
+def set_unscheduled_maintenance(entity_name, check_name, duration)
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-def remove_notifications(entity, check)
-  event_id = entity + ":" + check
-  @redis.del("#{event_id}:last_problem_notification")
-  @redis.del("#{event_id}:last_recovery_notification")
-  @redis.del("#{event_id}:last_acknowledgement_notification")
+  t = Time.now
+  unsched_maint = Flapjack::Data::UnscheduledMaintenance.new(:start_time => t,
+    :end_time => Time.at(t.to_i + duration), :summary => 'fixing now')
+  expect(unsched_maint.save).to be true
+  check.set_unscheduled_maintenance(unsched_maint)
 end
 
-def set_ok_state(entity, check)
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  entity_check.update_state(Flapjack::Data::EntityCheck::STATE_OK,
-    :timestamp => (Time.now.to_i - (60*60*24)))
-end
+def clear_unscheduled_maintenance(entity_name, check_name)
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-def set_critical_state(entity, check)
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  entity_check.update_state(Flapjack::Data::EntityCheck::STATE_CRITICAL,
-    :timestamp => (Time.now.to_i - (60*60*24)))
+  check.clear_unscheduled_maintenance(Time.now)
 end
 
-def set_warning_state(entity, check)
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  entity_check.update_state(Flapjack::Data::EntityCheck::STATE_WARNING,
-    :timestamp => (Time.now.to_i - (60*60*24)))
-end
+def set_state(entity_name, check_name, condition, last_update = Time.now)
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-def end_unscheduled_maintenance(entity, check)
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  entity_check.end_unscheduled_maintenance(Time.now.to_i)
+  state = Flapjack::Data::State.new(:created_at => last_update, :updated_at => last_update,
+    :condition => condition)
+  state.save
+  check.states << state
 end
 
-def submit_ok(entity, check)
-  event = {
-    'type'    => 'service',
-    'state'   => 'ok',
-    'summary' => '0% packet loss',
-    'entity'  => entity,
-    'check'   => check
-  }
-  submit_event(event)
-end
-
-def submit_warning(entity, check)
-  event = {
-    'type'    => 'service',
-    'state'   => 'warning',
-    'summary' => '25% packet loss',
-    'entity'  => entity,
-    'check'   => check
-  }
-  submit_event(event)
-end
-
-def submit_critical(entity, check)
-  event = {
-    'type'    => 'service',
-    'state'   => 'critical',
-    'summary' => '100% packet loss',
-    'entity'  => entity,
-    'check'   => check
-  }
-  submit_event(event)
-end
-
-def submit_unknown(entity, check)
+def submit_event(condition, entity_name, check_name, opts = {})
+  err_rate = case condition
+  when 'ok'
+    '0'
+  when 'warning'
+    '25'
+  when 'critical'
+    '100'
+  end
   event = {
     'type'    => 'service',
-    'state'   => 'unknown',
-    'summary' => 'check execution error',
-    'entity'  => entity,
-    'check'   => check
+    'state'   => condition,
+    'summary' => "#{err_rate}% packet loss",
+    'entity'  => entity_name,
+    'check'   => check_name,
   }
-  submit_event(event)
+  ['initial', 'repeat'].each do |delay_type|
+    delay_key = "#{delay_type}_failure_delay".to_sym
+    event.update(delay_key => opts[delay_key]) unless opts[delay_key].nil?
+  end
+  Flapjack.redis.rpush('events', Flapjack.dump_json(event))
 end
 
-def submit_acknowledgement(entity, check)
+def submit_acknowledgement(entity_name, check_name)
   event = {
-    'type'               => 'action',
-    'state'              => 'acknowledgement',
-    'summary'            => "I'll have this fixed in a jiffy, saw the same thing yesterday",
-    'entity'             => entity,
-    'check'              => check
+    'type'    => 'action',
+    'state'   => 'acknowledgement',
+    'summary' => "I'll have this fixed in a jiffy, saw the same thing yesterday",
+    'entity'  => entity_name,
+    'check'   => check_name,
   }
-  submit_event(event)
+  Flapjack.redis.rpush('events', Flapjack.dump_json(event))
 end
 
-def submit_test(entity, check)
+def submit_test(entity_name, check_name)
   event = {
-    'type'               => 'action',
-    'state'              => 'test_notifications',
-    'summary'            => "test notification for all contacts interested in #{entity}",
-    'entity'             => entity,
-    'check'              => check
-  }
-  submit_event(event)
-end
-
-def icecube_schedule_to_time_restriction(sched, time_zone)
-  tr = sched.to_hash
-  tr[:start_time] = {:time => time_zone.utc_to_local(tr[:start_time][:time]).strftime("%Y-%m-%d %H:%M:%S"), :zone => time_zone}
-  tr[:end_time]   = {:time => time_zone.utc_to_local(tr[:end_time][:time]).strftime("%Y-%m-%d %H:%M:%S"), :zone => time_zone}
-
-  # rewrite IceCube::WeeklyRule to Weekly, etc
-  tr[:rrules].each {|rrule|
-    rrule[:rule_type] = /^.*\:\:(.*)Rule$/.match(rrule[:rule_type])[1]
+    'type'    => 'action',
+    'state'   => 'test_notifications',
+    'summary' => "test notification for all contacts interested in #{entity_name}",
+    'entity'  => entity_name,
+    'check'   => check_name,
   }
-
-  tr
-end
-
-Given /^an entity '([\w\.\-]+)' exists$/ do |entity|
-  Flapjack::Data::Entity.add({'id'       => '5000',
-                              'name'     => entity},
-                             :redis => @redis )
-end
-
-Given /^the check is check '(.*)' on entity '([\w\.\-]+)'$/ do |check, entity|
-  @check  = check
-  @entity = entity
+  Flapjack.redis.rpush('events', Flapjack.dump_json(event))
 end
 
-Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') has no state$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  remove_unscheduled_maintenance(entity, check)
-  remove_scheduled_maintenance(entity, check)
-  remove_notifications(entity, check)
-  @redis.hdel("check:#{@key}", 'state')
+def stringify(obj)
+  return obj.inject({}){|memo,(k,v)| memo[k.to_s] =  stringify(v); memo} if obj.is_a?(Hash)
+  return obj.inject([]){|memo,v    | memo         << stringify(v); memo} if obj.is_a?(Array)
+  obj
 end
 
-Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in an ok state$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  remove_unscheduled_maintenance(entity, check)
-  remove_scheduled_maintenance(entity, check)
-  remove_notifications(entity, check)
-  set_ok_state(entity, check)
-end
+Given /^the check is check '(.*)' on entity '([\w\.\-]+)'$/ do |check_name, entity_name|
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  if check.nil?
+    check = Flapjack::Data::Check.new(:name => "#{entity_name}:#{check_name}",
+      :enabled => true)
+    expect(check.save).to be true
+  end
 
-Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in a critical state$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  remove_unscheduled_maintenance(entity, check)
-  remove_scheduled_maintenance(entity, check)
-  remove_notifications(entity, check)
-  set_critical_state(entity, check)
+  @check_name  = check_name
+  @entity_name = entity_name
 end
 
-Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in scheduled maintenance(?: for (.+))?$/ do |check, entity, duration|
-  check  ||= @check
-  entity ||= @entity
-  durn = duration ? ChronicDuration.parse(duration) : 60*60*2
-  remove_unscheduled_maintenance(entity, check)
-  set_scheduled_maintenance(entity, check, durn)
+Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') has no state$/ do |check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
 end
 
-# TODO set the state directly rather than submit & drain
-Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in unscheduled maintenance$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  remove_scheduled_maintenance(entity, check)
-  set_critical_state(entity, check)
-  submit_acknowledgement(entity, check)
-  drain_events  # TODO these should only be in When clauses
+Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in an? (ok|critical) state$/ do |check_name, entity_name, state|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  set_state(entity_name, check_name, state, Time.now)
 end
 
-When /^an ok event is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_ok(entity, check)
-  drain_events
+Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in scheduled maintenance(?: for (.+))?$/ do |check_name, entity_name, duration|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  durn = duration ? ChronicDuration.parse(duration) : (6 * 60 *60)
+  set_scheduled_maintenance(entity_name, check_name, durn)
 end
 
-When /^a failure event is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_critical(entity, check)
-  drain_events
+Given /^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') is in unscheduled maintenance$/ do |check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  set_unscheduled_maintenance(entity_name, check_name, 60*60*2)
 end
 
-When /^a critical event is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_critical(entity, check)
+When /^an? (ok|failure|critical|warning|unknown) event(?: with an? (initial|repeat) failure delay of (\d+) seconds)? is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |condition, init_or_repeat, failure_delay, check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  opts = case init_or_repeat
+  when 'initial'
+    {:initial_failure_delay => failure_delay}
+  when 'repeat'
+    {:repeat_failure_delay => failure_delay}
+  else
+    {}
+  end
+  submit_event(condition, entity_name, check_name, opts)
   drain_events
 end
 
-When /^a warning event is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_warning(entity, check)
+When /^an acknowledgement .*is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  submit_acknowledgement(entity_name, check_name)
   drain_events
 end
 
-When /^an unknown event is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_unknown(entity, check)
+When /^a test .*is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  submit_test(entity_name, check_name)
   drain_events
 end
 
-When /^an acknowledgement .*is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_acknowledgement(entity, check)
-  drain_events
+When /^the unscheduled maintenance is ended(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
+  clear_unscheduled_maintenance(entity_name, check_name)
 end
 
-When /^a test .*is received(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  submit_test(entity, check)
-  drain_events
-end
+Then /^(no|\d+) notifications? should have been generated(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |count, check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
 
-When /^the unscheduled maintenance is ended(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  end_unscheduled_maintenance(entity, check)
-end
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-When /^check '([\w\.\-]+)' (?:for|on) entity '([\w\.\-]+)' is (dis|en)abled$/ do |check, entity, dis_en|
-  entity_check = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
-  case dis_en
-  when 'dis'
-    entity_check.disable!
-  when 'en'
-    entity_check.enable!
+  case count
+  when 'no', 0
+    expect(check.notification_count).to be_nil
+  else
+    expect(check.notification_count).to eq(count.to_i)
   end
 end
 
-# TODO logging is a side-effect, should test for notification generation itself
-Then /^a notification should not be generated(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  message = @logger.messages.find_all {|m| m =~ /enerating notification for event #{entity}:#{check}/ }.last
-  found = message ? message.match(/Not generating notification/) : false
-  expect(found).to be_truthy
-end
+Then /^(un)?scheduled maintenance should be generated(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |unsched, check_name, entity_name|
+  check_name  ||= @check_name
+  entity_name ||= @entity_name
 
-Then /^a notification should be generated(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  message = @logger.messages.find_all {|m| m =~ /enerating notification for event #{entity}:#{check}/ }.last
-  found = message ? message.match(/Generating notification/) : false
-  expect(found).to be_truthy
-end
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
 
-Then /^(un)?scheduled maintenance should be generated(?: for check '([\w\.\-]+)' on entity '([\w\.\-]+)')?$/ do |unsched, check, entity|
-  check  ||= @check
-  entity ||= @entity
-  expect(@redis.get("#{entity}:#{check}:#{unsched || ''}scheduled_maintenance")).not_to be_nil
+  expect(check).to (unsched ? be_in_unscheduled_maintenance : be_in_scheduled_maintenance)
 end
 
 Then /^show me the (\w+ )*log$/ do |adjective|
   puts "the #{adjective}log:"
-  puts @logger.messages.join("\n")
-end
-
-Then /^dump notification rules for user (\S+)$/ do |contact|
-  rule_ids = @redis.smembers("contact_notification_rules:#{contact}")
-  puts "There #{(rule_ids.length == 1) ? 'is' : 'are'} #{rule_ids.length} notification rule#{(rule_ids.length == 1) ? '' : 's'} for user #{contact}:"
-  rule_ids.each {|rule_id|
-    rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :redis => @redis)
-    puts Flapjack.dump_json(rule)
-  }
-end
-
-# added for notification rules:
-Given /^the following entities exist:$/ do |entities|
-  entities.hashes.each do |entity|
-    contacts = entity['contacts'].split(',')
-    contacts.map! do |contact|
-      contact.strip
-    end
-    Flapjack::Data::Entity.add({'id'       => entity['id'],
-                                'name'     => entity['name'],
-                                'contacts' => contacts},
-                               :redis => @redis )
-  end
-end
-
-Given /^the following users exist:$/ do |contacts|
-  contacts.hashes.each do |contact|
-    media = {}
-    media['email'] = { 'address' => contact['email'] }
-    media['sms']   = { 'address' => contact['sms'] }
-    Flapjack::Data::Contact.add({'id'         => contact['id'],
-                                 'first_name' => contact['first_name'],
-                                 'last_name'  => contact['last_name'],
-                                 'email'      => contact['email'],
-                                 'media'      => media},
-                                :redis => @redis ).timezone = contact['timezone']
-  end
-end
-
-Given /^user (\S+) has the following notification intervals:$/ do |contact_id, intervals|
-  contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => @redis)
-  intervals.hashes.each do |interval|
-    contact.set_interval_for_media('email', interval['email'].to_i * 60)
-    contact.set_interval_for_media('sms',   interval['sms'].to_i * 60)
-  end
-end
-
-Given /^user (\S+) has the following notification rollup thresholds:$/ do |contact_id, rollup_thresholds|
-  contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => @redis)
-  rollup_thresholds.hashes.each do |rollup_threshold|
-    contact.set_rollup_threshold_for_media('email', rollup_threshold['email'].to_i)
-    contact.set_rollup_threshold_for_media('sms',   rollup_threshold['sms'].to_i)
-  end
-end
-
-Given /^user (\S+) has the following notification rules:$/ do |contact_id, rules|
-  contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => @redis)
-  time_zone = contact.time_zone
-
-  # delete any autogenerated rules, and do it using redis directly so no new
-  # ones will be created
-  contact.notification_rules.each do |nr|
-    @redis.srem("contact_notification_rules:#{contact_id}", nr.id)
-    @redis.del("notification_rule:#{nr.id}")
-  end
-  rules.hashes.each do |rule|
-    entities           = rule['entities']           ? rule['entities'].split(',').map       {|x| x.strip } : []
-    regex_entities     = rule['regex_entities']     ? rule['regex_entities'].split(',').map {|x| x.strip } : []
-    tags               = rule['tags']               ? rule['tags'].split(',').map           {|x| x.strip } : []
-    unknown_media      = rule['unknown_media']      ? rule['unknown_media'].split(',').map  {|x| x.strip } : []
-    warning_media      = rule['warning_media']      ? rule['warning_media'].split(',').map  {|x| x.strip } : []
-    critical_media     = rule['critical_media']     ? rule['critical_media'].split(',').map {|x| x.strip } : []
-    unknown_blackhole  = rule['unknown_blackhole']  ? (rule['unknown_blackhole'].downcase == 'true')  : false
-    warning_blackhole  = rule['warning_blackhole']  ? (rule['warning_blackhole'].downcase == 'true')  : false
-    critical_blackhole = rule['critical_blackhole'] ? (rule['critical_blackhole'].downcase == 'true') : false
-    time_restrictions  = rule['time_restrictions']  ? rule['time_restrictions'].split(',').map { |x|
-      x.strip
-    }.inject([]) { |memo, time_restriction|
-      case time_restriction
-      when '8-18 weekdays'
-        weekdays_8_18 = IceCube::Schedule.new(time_zone.local(2013,2,1,8,0,0), :duration => 60 * 60 * 10)
-        weekdays_8_18.add_recurrence_rule(IceCube::Rule.weekly.day(:monday, :tuesday, :wednesday, :thursday, :friday))
-        memo << icecube_schedule_to_time_restriction(weekdays_8_18, time_zone)
-      end
-    } : []
-    rule_data = {:contact_id         => contact_id,
-                 :entities           => entities,
-                 :regex_entities     => regex_entities,
-                 :tags               => tags,
-                 :unknown_media      => unknown_media,
-                 :warning_media      => warning_media,
-                 :critical_media     => critical_media,
-                 :unknown_blackhole  => unknown_blackhole,
-                 :warning_blackhole  => warning_blackhole,
-                 :critical_blackhole => critical_blackhole,
-                 :time_restrictions  => time_restrictions}
-    created_rule = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-    unless created_rule.is_a?(Flapjack::Data::NotificationRule)
-      raise "Error creating notification rule with data: #{rule_data}, errors: #{created_rule.join(', ')}"
-    end
-  end
-end
-
-Then /^all alert dropping keys for user (\S+) should have expired$/ do |contact_id|
-  expect(@redis.keys("drop_alerts_for_contact:#{contact_id}:*")).to be_empty
+  puts Flapjack.logger.messages.join("\n")
 end
 
 Then /^(\w+) (\w+) alert(?:s)?(?: of)?(?: type (\w+))?(?: and)?(?: rollup (\w+))? should be queued for (.*)$/ do |num_queued, media, notification_type, rollup, address|
-  check  = check  ? check  : @check
-  entity = entity ? entity : @entity
   case num_queued
   when 'no'
     num_queued = 0
   end
-  queued = redis_peek("#{media}_notifications", 0, 30)
-  queued_length = queued.find_all {|n|
-    type_ok = notification_type ? ( n['notification_type'] == notification_type ) : true
-    rollup_ok = case rollup
-    when 'none'
-      n['rollup'].nil?
-    when nil, n['rollup']
-      true
-    else
-      false
+  queued = redis_peek("#{media}_notifications", Flapjack::Data::Alert, 0, 30)
+  queued_length = queued.find_all {|alert|
+    type_ok = notification_type ? ( alert.notification_type == notification_type ) : true
+    rollup_ok = true
+    if rollup
+      if rollup == 'none'
+        rollup_ok = alert.rollup.nil?
+      else
+        rollup_ok = (alert.rollup == rollup)
+      end
     end
-    type_ok && rollup_ok && ( n['address'] == address )
+    type_ok && rollup_ok && (alert.medium.address == address)
   }.length
   expect(queued_length).to eq(num_queued.to_i)
 end
 
-When(/^user (\S+) ceases to be a contact of entity '(.*)'$/) do |contact_id, entity|
-  entity = Flapjack::Data::Entity.find_by_name(entity, :redis => @redis)
-  @redis.srem("contacts_for:#{entity.id}", contact_id)
-end
+When(/^the rule with id '(\S+)' is removed$/) do |rule_id|
+  rule = Flapjack::Data::Rule.find_by_id(rule_id)
+  expect(rule).not_to be_nil
 
-Then(/^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') should not appear in unacknowledged_failing$/) do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  unacknowledged_failing_checks = Flapjack::Data::EntityCheck.unacknowledged_failing(:redis => @redis)
-  expect(unacknowledged_failing_checks.map {|ec| "#{ec.entity.name}:#{ec.check}"}).to_not include("#{entity}:#{check}")
-end
+  # # this should happen anyway...
+  # rule.contact.rules.remove(rule) unless rule.contact.nil?
 
-Then(/^(?:the check|check '([\w\.\-]+)' for entity '([\w\.\-]+)') should appear in unacknowledged_failing$/) do |check, entity|
-  check  ||= @check
-  entity ||= @entity
-  unacknowledged_failing_checks = Flapjack::Data::EntityCheck.unacknowledged_failing(:redis => @redis)
-  expect(unacknowledged_failing_checks.map {|ec| "#{ec.entity.name}:#{ec.check}"}).to include("#{entity}:#{check}")
+  rule.destroy
 end
 
+When /^check '([\w\.\-]+)' (?:for|on) entity '([\w\.\-]+)' is (dis|en)abled$/ do |check_name, entity_name, dis_en|
+  check = Flapjack::Data::Check.intersect(:name => "#{entity_name}:#{check_name}").all.first
+  expect(check).not_to be_nil
+
+  check.enabled = 'en'.eql?(dis_en)
+  check.save!
+end