flapjack 1.1.0 → 1.2.0rc1

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

@@ -5,7 +5,7 @@ describe Flapjack::Data::Event do
 
   let(:entity_name) { 'xyz-example.com' }
   let(:check)       { 'ping' }
-  let(:mock_redis)  { double(::Redis) }
+  let(:redis)       { double(::Redis) }
 
   let!(:time) { Time.now}
 
@@ -25,66 +25,66 @@ describe Flapjack::Data::Event do
   context 'class' do
 
     it "returns the next event (blocking, archiving)" do
-      expect(mock_redis).to receive(:brpoplpush).
+      expect(redis).to receive(:brpoplpush).
         with('events', /^events_archive:/, 0).and_return(event_data.to_json)
-      expect(mock_redis).to receive(:expire)
+      expect(redis).to receive(:expire)
 
       result = Flapjack::Data::Event.next('events', :block => true,
-        :archive_events => true, :redis => mock_redis)
+        :archive_events => true, :redis => redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (blocking, not archiving)" do
-      expect(mock_redis).to receive(:brpop).with('events', 0).
+      expect(redis).to receive(:brpop).with('events', 0).
         and_return(['events', event_data.to_json])
 
       result = Flapjack::Data::Event.next('events',:block => true,
-        :archive_events => false, :redis => mock_redis)
+        :archive_events => false, :redis => redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, archiving)" do
-      expect(mock_redis).to receive(:rpoplpush).
+      expect(redis).to receive(:rpoplpush).
         with('events', /^events_archive:/).and_return(event_data.to_json)
-      expect(mock_redis).to receive(:expire)
+      expect(redis).to receive(:expire)
 
       result = Flapjack::Data::Event.next('events', :block => false,
-        :archive_events => true, :redis => mock_redis)
+        :archive_events => true, :redis => redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, not archiving)" do
-      expect(mock_redis).to receive(:rpop).with('events').
+      expect(redis).to receive(:rpop).with('events').
         and_return(event_data.to_json)
 
       result = Flapjack::Data::Event.next('events', :block => false,
-        :archive_events => false, :redis => mock_redis)
+        :archive_events => false, :redis => redis)
       expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "rejects invalid event JSON (archiving)" do
       bad_event_json = '{{{'
-      expect(mock_redis).to receive(:brpoplpush).
+      expect(redis).to receive(:brpoplpush).
         with('events', /^events_archive:/, 0).and_return(bad_event_json)
-      expect(mock_redis).to receive(:multi)
-      expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-      expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-      expect(mock_redis).to receive(:exec)
-      expect(mock_redis).to receive(:expire)
+      expect(redis).to receive(:multi)
+      expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+      expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+      expect(redis).to receive(:exec)
+      expect(redis).to receive(:expire)
 
       result = Flapjack::Data::Event.next('events', :block => true,
-        :archive_events => true, :redis => mock_redis)
+        :archive_events => true, :redis => redis)
       expect(result).to be_nil
     end
 
     it "rejects invalid event JSON (not archiving)" do
       bad_event_json = '{{{'
-      expect(mock_redis).to receive(:brpop).with('events', 0).
+      expect(redis).to receive(:brpop).with('events', 0).
         and_return(['events', bad_event_json])
-      expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+      expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
 
       result = Flapjack::Data::Event.next('events', :block => true,
-        :archive_events => false, :redis => mock_redis)
+        :archive_events => false, :redis => redis)
       expect(result).to be_nil
     end
 
@@ -94,16 +94,16 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data.delete(required_key)
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpoplpush).
+        expect(redis).to receive(:brpoplpush).
           with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(mock_redis).to receive(:multi)
-        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(mock_redis).to receive(:exec)
-        expect(mock_redis).to receive(:expire)
+        expect(redis).to receive(:multi)
+        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:exec)
+        expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => mock_redis)
+          :archive_events => true, :redis => redis)
         expect(result).to be_nil
       end
 
@@ -111,12 +111,12 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data.delete(required_key)
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpop).with('events', 0).
+        expect(redis).to receive(:brpop).with('events', 0).
           and_return(['events', bad_event_json])
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => mock_redis)
+          :archive_events => false, :redis => redis)
         expect(result).to be_nil
       end
 
@@ -124,16 +124,16 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data[required_key] = {'hello' => 'there'}
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpoplpush).
+        expect(redis).to receive(:brpoplpush).
           with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(mock_redis).to receive(:multi)
-        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(mock_redis).to receive(:exec)
-        expect(mock_redis).to receive(:expire)
+        expect(redis).to receive(:multi)
+        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:exec)
+        expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => mock_redis)
+          :archive_events => true, :redis => redis)
         expect(result).to be_nil
       end
 
@@ -141,12 +141,12 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data[required_key] = {'hello' => 'there'}
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpop).with('events', 0).
+        expect(redis).to receive(:brpop).with('events', 0).
           and_return(['events', bad_event_json])
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => mock_redis)
+          :archive_events => false, :redis => redis)
         expect(result).to be_nil
       end
     end
@@ -156,16 +156,16 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data[optional_key] = {'hello' => 'there'}
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpoplpush).
+        expect(redis).to receive(:brpoplpush).
           with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(mock_redis).to receive(:multi)
-        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(mock_redis).to receive(:exec)
-        expect(mock_redis).to receive(:expire)
+        expect(redis).to receive(:multi)
+        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:exec)
+        expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => mock_redis)
+          :archive_events => true, :redis => redis)
         expect(result).to be_nil
       end
 
@@ -173,12 +173,12 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data[optional_key] = {'hello' => 'there'}
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpop).with('events', 0).
+        expect(redis).to receive(:brpop).with('events', 0).
           and_return(['events', bad_event_json])
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => mock_redis)
+          :archive_events => false, :redis => redis)
         expect(result).to be_nil
       end
     end
@@ -188,23 +188,23 @@ describe Flapjack::Data::Event do
       it "it matches case-insensitively for #{key} (archiving)" do
         case_event_data = event_data.clone
         case_event_data[key] = event_data[key].upcase
-        expect(mock_redis).to receive(:brpoplpush).
+        expect(redis).to receive(:brpoplpush).
           with('events', /^events_archive:/, 0).and_return(case_event_data.to_json)
-        expect(mock_redis).to receive(:expire)
+        expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => mock_redis)
+          :archive_events => true, :redis => redis)
         expect(result).to be_an_instance_of(Flapjack::Data::Event)
       end
 
       it "it matches case-insensitively for #{key} (not archiving)" do
         case_event_data = event_data.clone
         case_event_data[key] = event_data[key].upcase
-        expect(mock_redis).to receive(:brpop).with('events', 0).
+        expect(redis).to receive(:brpop).with('events', 0).
           and_return(['events', case_event_data.to_json])
 
         result = Flapjack::Data::Event.next('events',:block => true,
-          :archive_events => false, :redis => mock_redis)
+          :archive_events => false, :redis => redis)
         expect(result).to be_an_instance_of(Flapjack::Data::Event)
       end
     end
@@ -214,23 +214,23 @@ describe Flapjack::Data::Event do
       it "it accepts an event with a numeric #{key} key (archiving)" do
         num_event_data = event_data.clone
         num_event_data[key] = event_data[key].to_i.to_s
-        expect(mock_redis).to receive(:brpoplpush).
+        expect(redis).to receive(:brpoplpush).
           with('events', /^events_archive:/, 0).and_return(num_event_data.to_json)
-        expect(mock_redis).to receive(:expire)
+        expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => mock_redis)
+          :archive_events => true, :redis => redis)
         expect(result).to be_an_instance_of(Flapjack::Data::Event)
       end
 
       it "it accepts an event with a numeric #{key} key (not archiving)" do
         num_event_data = event_data.clone
         num_event_data[key] = event_data[key].to_i.to_s
-        expect(mock_redis).to receive(:brpop).with('events', 0).
+        expect(redis).to receive(:brpop).with('events', 0).
           and_return(['events', num_event_data.to_json])
 
         result = Flapjack::Data::Event.next('events',:block => true,
-          :archive_events => false, :redis => mock_redis)
+          :archive_events => false, :redis => redis)
         expect(result).to be_an_instance_of(Flapjack::Data::Event)
       end
 
@@ -238,16 +238,16 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data[key] = 'NaN'
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpoplpush).
+        expect(redis).to receive(:brpoplpush).
           with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(mock_redis).to receive(:multi)
-        expect(mock_redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(mock_redis).to receive(:exec)
-        expect(mock_redis).to receive(:expire)
+        expect(redis).to receive(:multi)
+        expect(redis).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:exec)
+        expect(redis).to receive(:expire)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => mock_redis)
+          :archive_events => true, :redis => redis)
         expect(result).to be_nil
       end
 
@@ -255,12 +255,12 @@ describe Flapjack::Data::Event do
         bad_event_data = event_data.clone
         bad_event_data[key] = 'NaN'
         bad_event_json = bad_event_data.to_json
-        expect(mock_redis).to receive(:brpop).with('events', 0).
+        expect(redis).to receive(:brpop).with('events', 0).
           and_return(['events', bad_event_json])
-        expect(mock_redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
+        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
 
         result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => mock_redis)
+          :archive_events => false, :redis => redis)
         expect(result).to be_nil
       end
 
@@ -268,26 +268,26 @@ describe Flapjack::Data::Event do
 
     it "returns a count of pending events" do
       events_len = 23
-      expect(mock_redis).to receive(:llen).with('events').and_return(events_len)
+      expect(redis).to receive(:llen).with('events').and_return(events_len)
 
-      pc = Flapjack::Data::Event.pending_count('events', :redis => mock_redis)
+      pc = Flapjack::Data::Event.pending_count('events', :redis => redis)
       expect(pc).to eq(events_len)
     end
 
     it "creates a notification testing event" do
       expect(Time).to receive(:now).and_return(time)
-      expect(mock_redis).to receive(:lpush).with('events', /"testing"/ )
+      expect(redis).to receive(:lpush).with('events', /"testing"/ )
 
       Flapjack::Data::Event.test_notifications(entity_name, check,
-        :summary => 'test', :details => 'testing', :redis => mock_redis)
+        :summary => 'test', :details => 'testing', :redis => redis)
     end
 
     it "creates an acknowledgement event" do
       expect(Time).to receive(:now).and_return(time)
-      expect(mock_redis).to receive(:lpush).with('events', /"acking"/ )
+      expect(redis).to receive(:lpush).with('events', /"acking"/ )
 
       Flapjack::Data::Event.create_acknowledgement(entity_name, check,
-        :summary => 'acking', :time => time.to_i, :redis => mock_redis)
+        :summary => 'acking', :time => time.to_i, :redis => redis)
     end
 
   end
@@ -302,7 +302,7 @@ describe Flapjack::Data::Event do
       expect(event.time).to eq(event_data['time'])
       expect(event.id).to eq('xyz-example.com:ping')
       expect(event.type).to eq('service')
-      expect(event.tags).to be_an_instance_of(Flapjack::Data::TagSet)
+      expect(event.tags).to be_an_instance_of(Set)
       expect(event.tags).to include('dev')
       expect(event.tags).to_not include('prod')
 

data/spec/lib/flapjack/data/notification_rule_spec.rb

@@ -90,8 +90,10 @@ describe Flapjack::Data::NotificationRule, :redis => true do
 
   it "generates a JSON string representing its data" do
     rule = existing_rule
-    # bit of extra hackery for the inserted ID values
-    expect(rule.to_json).to eq({:id => rule.id}.merge(rule_data).to_json)
+    # bit of extra hackery for the ID values
+    munged = {:id => rule.id}.merge(rule_data)
+    munged[:links] = {:contacts => [munged.delete(:contact_id)]}
+    expect(rule.to_jsonapi).to eq(Flapjack.dump_json(munged))
   end
 
   it "checks whether entity names match" do

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

@@ -18,12 +18,16 @@ describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger
 
   it "retrieves all checks" do
     expect(entity).to receive(:id).and_return('23')
+    expect(entity).to receive(:name).exactly(3).times.and_return('www.example.net')
 
-    expect(entity_check).to receive(:entity).and_return(entity)
-    expect(entity_check).to receive(:key).twice.and_return('PING')
+    expect(Flapjack::Data::EntityCheck).to receive(:enabled_for).
+      with(['www.example.net:PING'], :redis => redis).and_return(['www.example.net:PING'])
+
+    expect(entity_check).to receive(:entity).exactly(3).times.and_return(entity)
+    expect(entity_check).to receive(:check).exactly(3).times.and_return('PING')
     expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
-    expect(Flapjack::Data::EntityCheck).to receive(:find_current).with(:redis => redis).
-      and_return([entity_check])
+    expect(Flapjack::Data::EntityCheck).to receive(:all).
+      with(:logger => @logger, :redis => redis).and_return([entity_check])
 
     aget '/checks'
     expect(last_response).to be_ok
@@ -32,9 +36,13 @@ describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger
 
   it "retrieves one check" do
     expect(entity).to receive(:id).and_return('23')
+    expect(entity).to receive(:name).exactly(3).times.and_return('www.example.net')
 
-    expect(entity_check).to receive(:entity).and_return(entity)
-    expect(entity_check).to receive(:key).twice.and_return('PING')
+    expect(Flapjack::Data::EntityCheck).to receive(:enabled_for).
+      with(['www.example.net:PING'], :redis => redis).and_return(['www.example.net:PING'])
+
+    expect(entity_check).to receive(:entity).exactly(3).times.and_return(entity)
+    expect(entity_check).to receive(:check).exactly(3).times.and_return('PING')
     expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
     expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
       with('www.example.com:PING', :logger => @logger, :redis => redis).
@@ -45,22 +53,27 @@ describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger
     expect(last_response.body).to eq({:checks => [check_data]}.to_json)
   end
 
-  it "retrieves several entities" do
+  it "retrieves several checks" do
     entity_check_2 = double(Flapjack::Data::EntityCheck)
     check_data_2 = {'name'        => 'SSH',
                     'entity_name' => 'www.example.com'}
 
     expect(entity).to receive(:id).twice.and_return('23')
+    expect(entity).to receive(:name).exactly(6).times.and_return('www.example.net')
 
-    expect(entity_check).to receive(:entity).and_return(entity)
-    expect(entity_check).to receive(:key).twice.and_return('PING')
+    expect(Flapjack::Data::EntityCheck).to receive(:enabled_for).
+      with(['www.example.net:PING', 'www.example.net:SSH'], :redis => redis).
+      and_return(['www.example.net:PING', 'www.example.net:SSH'])
+
+    expect(entity_check).to receive(:entity).exactly(3).times.and_return(entity)
+    expect(entity_check).to receive(:check).exactly(3).times.and_return('PING')
     expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
     expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
       with('www.example.com:PING', :logger => @logger, :redis => redis).
       and_return(entity_check)
 
-    expect(entity_check_2).to receive(:entity).and_return(entity)
-    expect(entity_check_2).to receive(:key).twice.and_return('SSH')
+    expect(entity_check_2).to receive(:entity).exactly(3).times.and_return(entity)
+    expect(entity_check_2).to receive(:check).exactly(3).times.and_return('SSH')
     expect(entity_check_2).to receive(:to_jsonapi).and_return(check_data_2.to_json)
     expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
       with('www.example.com:SSH', :logger => @logger, :redis => redis).
@@ -70,6 +83,35 @@ describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger
     expect(last_response).to be_ok
     expect(last_response.body).to eq({:checks => [check_data, check_data_2]}.to_json)
   end
+  it "creates checks from a submitted list" do
+    checks = {'checks' =>
+      [
+       {"entity_id" => "10001",
+        "name" => "PING"
+       },
+       {"entity_id" => "10001",
+        "name" => "SSH"
+       }
+      ]
+    }
+
+    entity_check_2 = double(Flapjack::Data::EntityCheck)
+    expect(entity).to receive(:name).twice.and_return('example.com')
+
+    expect(entity_check).to receive(:entity).and_return(entity)
+    expect(entity_check_2).to receive(:entity).and_return(entity)
+
+    expect(entity_check).to receive(:check).and_return('PING')
+    expect(entity_check_2).to receive(:check).and_return('SSH')
+
+    expect(Flapjack::Data::EntityCheck).to receive(:add).twice.
+      and_return(entity_check, entity_check_2)
+
+    apost "/checks", checks.to_json, jsonapi_post_env
+    expect(last_response.status).to eq(201)
+    expect(last_response.headers['Location']).to eq("http://example.org/checks/example.com:PING,example.com:SSH")
+    expect(last_response.body).to eq('["example.com:PING","example.com:SSH"]')
+  end
 
   it 'disables a check' do
     expect(Flapjack::Data::Entity).to receive(:find_by_name).
@@ -83,7 +125,48 @@ describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger
       [{:op => 'replace', :path => '/checks/0/enabled', :value => false}].to_json,
       jsonapi_patch_env
     expect(last_response.status).to eq(204)
+  end
+
+  it 'enables a check' do
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    expect(entity_check).to receive(:enable!)
+
+    apatch "/checks/#{check_esc}",
+      [{:op => 'replace', :path => '/checks/0/enabled', :value => true}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
+  it "adds tags to a check" do
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    expect(entity_check).to receive(:add_tags).with('database', 'virtualised')
+
+    apatch "/checks/#{check_esc}",
+      [{:op => 'add', :path => '/checks/0/links/tags', :value => ['database', 'virtualised']}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
+  it "removes tags from a check" do
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    expect(entity_check).to receive(:delete_tags).with('database')
 
+    apatch "/checks/#{check_esc}",
+      [{:op => 'remove', :path => '/checks/0/links/tags/database'}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
   end
 
   it "creates an acknowledgement for an entity check" do

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

@@ -21,6 +21,8 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
 
     expect(Flapjack::Data::Entity).to receive(:contact_ids_for).
       with([entity_core['id']], :redis => redis).and_return({})
+    expect(Flapjack::Data::Entity).to receive(:check_ids_for).
+      with([entity_core['id']], :redis => redis).and_return({})
     expect(entity).to receive(:to_jsonapi).and_return(entity_core.to_json)
     expect(Flapjack::Data::Entity).to receive(:all).with(:enabled => nil, :redis => redis).
       and_return([entity])
@@ -36,6 +38,8 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
     expect(entity).to receive(:id).exactly(4).times.and_return(entity_core['id'])
     expect(Flapjack::Data::Entity).to receive(:contact_ids_for).
       with([entity_core['id']], :redis => redis).and_return({})
+    expect(Flapjack::Data::Entity).to receive(:check_ids_for).
+      with([entity_core['id']], :redis => redis).and_return({})
     expect(entity).to receive(:to_jsonapi).and_return(entity_core.to_json)
     expect(idless_entity).not_to receive(:to_jsonapi)
     expect(Flapjack::Data::Entity).to receive(:all).with(:enabled => nil, :redis => redis).
@@ -53,6 +57,8 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
 
     expect(Flapjack::Data::Entity).to receive(:contact_ids_for).
       with(['1234'], :redis => redis).and_return({})
+    expect(Flapjack::Data::Entity).to receive(:check_ids_for).
+      with(['1234'], :redis => redis).and_return({})
     expect(entity).to receive(:to_jsonapi).and_return(entity_core.to_json)
     expect(Flapjack::Data::Entity).to receive(:find_by_id).
       with('1234', :logger => @logger, :redis => redis).
@@ -73,6 +79,9 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
     expect(Flapjack::Data::Entity).to receive(:contact_ids_for).
       with(['1234', '5678'], :redis => redis).and_return({})
 
+    expect(Flapjack::Data::Entity).to receive(:check_ids_for).
+      with(['1234', '5678'], :redis => redis).and_return({})
+
     expect(entity).to receive(:id).twice.and_return('1234')
     expect(entity_2).to receive(:id).twice.and_return('5678')
 
@@ -152,6 +161,81 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
     expect(last_response.status).to eq(204)
   end
 
+  it "adds tags to an entity" do
+    expect(Flapjack::Data::Entity).to receive(:find_by_id).
+      with('1234', :redis => redis).and_return(entity)
+
+    expect(entity).to receive(:add_tags).with('database')
+
+    apatch "/entities/1234",
+      [{:op => 'add', :path => '/entities/0/links/tags', :value => 'database'}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
+  it "removes tags from an entity" do
+    expect(Flapjack::Data::Entity).to receive(:find_by_id).
+      with('1234', :redis => redis).and_return(entity)
+
+    expect(entity).to receive(:delete_tags).with('database')
+    expect(entity).to receive(:delete_tags).with('virtualised')
+
+    apatch "/entities/1234",
+      [{:op => 'remove', :path => '/entities/0/links/tags/database'},
+       {:op => 'remove', :path => '/entities/0/links/tags/virtualised'}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
+  it "renames an entity when an entity with the new name doesn't exist" do
+    expect(entity).to receive(:name).and_return('example.com')
+    expect(Flapjack::Data::Entity).to receive(:find_by_id).
+      with('1234', :redis => redis).and_return(entity)
+
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).
+      with('example2.com', :redis => redis).and_return(nil)
+
+    expect(Flapjack::Data::Entity).to receive(:rename).
+      with('example.com', 'example2.com', :redis => redis)
+
+    apatch "/entities/1234",
+      [{:op => 'replace', :path => '/entities/0/name', :value => 'example2.com'}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
+  it "merges an entity when an entity with the new name exists" do
+    expect(entity).to receive(:name).and_return('example.com')
+    expect(Flapjack::Data::Entity).to receive(:find_by_id).
+      with('1234', :redis => redis).and_return(entity)
+
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).
+      with('example2.com', :redis => redis).and_return(double(Flapjack::Data::Entity))
+
+    expect(Flapjack::Data::Entity).to receive(:merge).
+      with('example.com', 'example2.com', :redis => redis)
+
+    apatch "/entities/1234",
+      [{:op => 'replace', :path => '/entities/0/name', :value => 'example2.com'}].to_json,
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
+  it 'skips a rename if old and new names are the same' do
+    expect(entity).to receive(:name).and_return('example.com')
+    expect(Flapjack::Data::Entity).to receive(:find_by_id).
+      with('1234', :redis => redis).and_return(entity)
+
+    expect(Flapjack::Data::Entity).not_to receive(:find_by_name)
+    expect(Flapjack::Data::Entity).not_to receive(:rename)
+
+    apatch "/entities/1234",
+      [{:op => 'replace', :path => '/entities/0/name', :value => 'example.com'}].to_json,
+
+      jsonapi_patch_env
+    expect(last_response.status).to eq(204)
+  end
+
   it "creates acknowledgements for all checks on an entity" do
     expect(entity).to receive(:check_list).and_return([check])
     expect(Flapjack::Data::Entity).to receive(:find_by_id).