flapjack-diner 1.4.0 → 2.0.0.a4

data/spec/argument_validator_spec.rb

@@ -6,88 +6,143 @@ describe Flapjack::ArgumentValidator do
   context 'required' do
 
     let(:query) do
-      {:entity => 'myservice', :check => 'HOST'}
+      {:name => 'HOST', :enabled => false}
     end
 
     subject { Flapjack::ArgumentValidator.new(query) }
 
-    it 'does not raise an exception when query entity is valid' do
-      expect { subject.validate(:query => :entity, :as => :required) }.not_to raise_exception
+    it 'does not raise an error when query entity is valid' do
+      expect {
+        subject.validate(:query => :name, :as => :required)
+      }.not_to raise_error
     end
 
     it 'raises ArgumentError when query entity is invalid' do
-      query[:entity] = nil
-      expect { subject.validate(:query => :entity, :as => :required) }.to raise_exception
+      query[:name] = nil
+      expect {
+        subject.validate(:query => :name, :as => :required)
+      }.to raise_error(ArgumentError)
     end
 
     it 'handles arrays as query values valid' do
-      expect { subject.validate(:query => [:entity, :check], :as => :required) }.not_to raise_exception
+      expect {
+        subject.validate(:query => [:name, :enabled], :as => :required)
+      }.not_to raise_error
     end
 
     it 'handles arrays as query values invalid' do
-      query[:check] = nil
-      expect { subject.validate(:query => [:entity, :check], :as => :required) }.to raise_exception
+      query[:name] = nil
+      expect {
+        subject.validate(:query => [:name, :enabled], :as => :required)
+      }.to raise_error(ArgumentError)
     end
   end
 
   context 'time' do
 
     let(:query) do
-      {:start_time => Time.now, :duration => 10}
+      {:start_time => Time.now}
     end
 
     subject { Flapjack::ArgumentValidator.new(query) }
 
-    it 'does not raise an exception when query start_time is valid' do
-      expect { subject.validate(:query => :start_time, :as => :time) }.not_to raise_exception
+    it 'does not raise an error when query start_time is valid' do
+      expect {
+        subject.validate(:query => :start_time, :as => :time)
+      }.not_to raise_error
     end
 
-    it 'raises an exception when query start_time is invalid' do
+    it 'raises an error when query start_time is invalid' do
       query[:start_time] = 1234
-      expect { subject.validate(:query => :start_time, :as => :time) }.to raise_exception
+      expect {
+        subject.validate(:query => :start_time, :as => :time)
+      }.to raise_error(ArgumentError)
     end
 
     it 'handles arrays as query values valid' do
       query[:end_time] = Time.now
-      expect { subject.validate(:query => [:start_time, :end_time], :as => :time) }.not_to raise_exception
+      expect {
+        subject.validate(:query => [:start_time, :end_time], :as => :time)
+      }.not_to raise_error
     end
 
     it 'handles arrays as query values invalid' do
       query[:end_time] = 3904
-      expect { subject.validate(:query => [:start_time, :end_time], :as => :time) }.to raise_exception
+      expect {
+        subject.validate(:query => [:start_time, :end_time], :as => :time)
+      }.to raise_error(ArgumentError)
     end
 
     it 'handles dates as query values' do
       query[:end_time] = Date.today
-      expect { subject.validate(:query => :end_time, :as => :time) }.not_to raise_exception
+      expect {
+        subject.validate(:query => :end_time, :as => :time)
+      }.not_to raise_error
     end
 
     it 'handles ISO 8601 strings as query values' do
       query[:end_time] = Time.now.iso8601
-      expect { subject.validate(:query => :end_time, :as => :time) }.not_to raise_exception
+      expect {
+        subject.validate(:query => :end_time, :as => :time)
+      }.not_to raise_error
     end
 
-    it 'raises an exception when invalid time strings are provided' do
+    it 'raises an error when invalid time strings are provided' do
       query[:end_time] = '2011-08-01T00:00'
-      expect { subject.validate(:query => :end_time, :as => :time) }.to raise_exception
+      expect {
+        subject.validate(:query => :end_time, :as => :time)
+      }.to raise_error(ArgumentError)
     end
   end
 
   context 'integer via method missing' do
 
     let(:query) do
-      {:start_time => Time.now, :duration => 10}
+      {:duration => 10}
     end
 
     subject { Flapjack::ArgumentValidator.new(query) }
 
-    it 'does not raise an exception when query duration is valid' do
-      expect { subject.validate(:query => :duration, :as => :integer) }.not_to raise_exception
+    it 'does not raise an error when query duration is valid' do
+      expect {
+        subject.validate(:query => :duration, :as => :integer)
+      }.not_to raise_error
     end
 
-    it 'raises an exception when query duration is invalid' do
+    it 'raises an error when query duration is invalid' do
       query[:duration] = '23'
-      expect { subject.validate(:query => :duration, :as => :integer) }.to raise_exception
+      expect {
+        subject.validate(:query => :duration, :as => :integer)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'string via method missing' do
+
+    let(:query) do
+      {:name => 'Herbert'}
+    end
+
+    subject { Flapjack::ArgumentValidator.new(query) }
+
+    it 'does not raise an error when query name is valid' do
+      expect {
+        subject.validate(:query => :name, :as => :non_empty_string)
+      }.not_to raise_error
+    end
+
+    it 'raises an error when query name is empty' do
+      query[:name] = ''
+      expect {
+        subject.validate(:query => :name, :as => :non_empty_string)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error when query name is invalid' do
+      query[:name] = 23
+      expect {
+        subject.validate(:query => :name, :as => :non_empty_string)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -99,13 +154,17 @@ describe Flapjack::ArgumentValidator do
 
     subject { Flapjack::ArgumentValidator.new(query) }
 
-    it 'does not raise an exception when query start_time is valid' do
-      expect { subject.validate(:query => :start_time, :as => [:time, :required]) }.not_to raise_exception
+    it 'does not raise an error when query start_time is valid' do
+      expect {
+        subject.validate(:query => :start_time, :as => [:time, :required])
+      }.not_to raise_error
     end
 
-    it 'raises an exception when query start_time is invalid' do
+    it 'raises an error when query start_time is invalid' do
       query[:start_time] = nil
-      expect { subject.validate(:query => :start_time, :as => [:time, :required]) }.to raise_exception
+      expect {
+        subject.validate(:query => :start_time, :as => [:time, :required])
+      }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/flapjack-diner_spec.rb

@@ -7,10 +7,6 @@ describe Flapjack::Diner do
 
   let(:time) { Time.now }
 
-  def response_with_data(name, data = [])
-    "{\"#{name}\":#{data.to_json}}"
-  end
-
   before(:each) do
     Flapjack::Diner.base_uri(server)
     Flapjack::Diner.logger = nil
@@ -20,9 +16,9 @@ describe Flapjack::Diner do
     WebMock.reset!
   end
 
-  context 'argument parsing' do
+  # context 'argument parsing' do
 
-  end
+  # end
 
   context 'keys as strings' do
 
@@ -35,32 +31,16 @@ describe Flapjack::Diner do
     end
 
     it 'can return keys as strings' do
-      data = [{
-        :id         => '21',
-        :first_name => 'Ada',
-        :last_name  => 'Lovelace',
-        :email      => 'ada@example.com',
-        :timezone   => 'Europe/London',
-        :tags       => [ 'legend', 'first computer programmer' ],
-        :links      => {
-          :entities           => ['7', '12', '83'],
-          :media              => ['21_email', '21_sms'],
-          :notification_rules => ['30fd36ae-3922-4957-ae3e-c8f6dd27e543']
-        }
-      }]
-
       req = stub_request(:get, "http://#{server}/contacts").to_return(
-        :status => 200, :body => response_with_data('contacts', data))
+        :status => 200, :body => {:data => [contact_data]}.to_json)
 
       result = Flapjack::Diner.contacts
       expect(req).to have_been_requested
       expect(result).not_to be_nil
       expect(result).to be_an_instance_of(Array)
       expect(result.length).to be(1)
-      expect(result[0]).to be_an_instance_of(Hash)
-      expect(result[0]).to have_key('id')
-      expect(result[0]).to have_key('links')
-      expect(result[0]['links']).to have_key('entities')
+      expect(result.first).to be_an_instance_of(Hash)
+      expect(result.first).to have_key('id')
     end
 
   end
@@ -73,65 +53,70 @@ describe Flapjack::Diner do
       Flapjack::Diner.logger = logger
     end
 
-    it 'logs a GET request without a path' do
-      response = response_with_data('entities')
-      req = stub_request(:get, "http://#{server}/entities").
+    it "logs a GET request without a path" do
+      response = {:data => [contact_data]}.to_json
+      req = stub_request(:get, "http://#{server}/contacts").
         to_return(:body => response)
 
-      expect(logger).to receive(:info).with("GET http://#{server}/entities")
-      expect(logger).to receive(:info).with('  Response Code: 200')
-      expect(logger).to receive(:info).with("  Response Body: #{response}")
+      expect(logger).to receive(:info).with(%r{\[Flapjack::Diner\] \[[^\]]+\] 200 "GET /contacts" - $})
 
-      result = Flapjack::Diner.entities
+      result = Flapjack::Diner.contacts
       expect(req).to have_been_requested
       expect(result).not_to be_nil
     end
 
     it "logs a POST request" do
-      req = stub_request(:post, "http://#{server}/test_notifications/entities/27").
-              to_return(:status => 204)
-      expect(logger).to receive(:info).with("POST http://#{server}/test_notifications/entities/27\n" +
-        "  Body: {:test_notifications=>[{:summary=>\"dealing with it\"}]}")
-      expect(logger).to receive(:info).with('  Response Code: 204')
+      req_data  = test_notification_json(test_notification_data).merge(
+        :relationships => {
+          :check => {
+            :data => {:type => 'check', :id => check_data[:id]}
+          }
+        }
+      )
+      resp_data = test_notification_json(test_notification_data)
+
+      response = {:data => resp_data}.to_json
+      req = stub_request(:post, "http://#{server}/test_notifications").
+              to_return(:status => 201, :body => response)
 
-      result = Flapjack::Diner.create_test_notifications_entities(27, [{:summary => 'dealing with it'}])
+      expect(logger).to receive(:info).with(%r{\[Flapjack::Diner\] \[[^\]]+\] 201 "POST /test_notifications" - $})
+
+      result = Flapjack::Diner.create_test_notifications(test_notification_data.merge(:check => check_data[:id]))
       expect(req).to have_been_requested
-      expect(result).to be_truthy
+      expect(result).to eq(resultify(resp_data))
     end
 
     it "logs a DELETE request" do
-      req = stub_request(:delete, "http://#{server}/scheduled_maintenances/checks/example.com%3ASSH").
-        with(:query => {:start_time => time.iso8601}).
+      req = stub_request(:delete, "http://#{server}/scheduled_maintenances/#{scheduled_maintenance_data[:id]}").
         to_return(:status => 204)
 
-      expect(logger).to receive(:info).with("DELETE http://#{server}/scheduled_maintenances/checks/example.com:SSH?start_time=#{URI.encode_www_form_component(time.iso8601)}")
-      expect(logger).to receive(:info).with("  Response Code: 204")
+      expect(logger).to receive(:info).
+        with(%r{\[Flapjack::Diner\] \[[^\]]+\] 204 "DELETE /scheduled_maintenances/#{scheduled_maintenance_data[:id]}" - $})
 
-      result = Flapjack::Diner.delete_scheduled_maintenances_checks('example.com:SSH', :start_time => time)
+      result = Flapjack::Diner.delete_scheduled_maintenances(scheduled_maintenance_data[:id])
       expect(req).to have_been_requested
-      expect(result).to be_truthy
+      expect(result).to be_a(TrueClass)
     end
 
   end
 
   context "problems" do
-
     it "raises an exception on network failure" do
-      req = stub_request(:get, "http://#{server}/entities").to_timeout
+      req = stub_request(:get, "http://#{server}/contacts").to_timeout
 
       expect {
-        Flapjack::Diner.entities
-      }.to raise_error
+        Flapjack::Diner.contacts
+      }.to raise_error(Timeout::Error)
       expect(req).to have_been_requested
     end
 
     it "raises an exception on invalid JSON data" do
-      req = stub_request(:get, "http://#{server}/entities").to_return(
+      req = stub_request(:get, "http://#{server}/contacts").to_return(
         :body => "{")
 
       expect {
-        Flapjack::Diner.entities
-      }.to raise_error
+        Flapjack::Diner.contacts
+      }.to raise_error(JSON::ParserError)
       expect(req).to have_been_requested
     end
 
@@ -139,26 +124,19 @@ describe Flapjack::Diner do
       req = stub_request(:get, /http:\/\/#{server}\/*/)
 
       expect {
-        Flapjack::Diner.delete_scheduled_maintenances_checks('example.com:SSH', :start_time => nil)
-      }.to raise_error
+        Flapjack::Diner.create_scheduled_maintenances
+      }.to raise_error(ArgumentError)
       expect(req).not_to have_been_requested
     end
 
     it "raises an exception if a time argument is provided with the wrong data type" do
-      start_str  = '2011-08-01T00:00:00+10:00'
-      finish_str = 'yesterday'
-
-      start  = Time.iso8601(start_str)
-
       req = stub_request(:get, /http:\/\/#{server}\/*/)
 
       expect {
-        Flapjack::Diner.downtime_report_checks('example.com:SSH',
-          :start_time => start_time, :end_time => end_time)
-      }.to raise_error
+        Flapjack::Diner.create_scheduled_maintenances(:start_time => Time.now,
+          :end_time => 'tomorrow')
+      }.to raise_error(ArgumentError)
       expect(req).not_to have_been_requested
     end
-
   end
-
 end

data/spec/relationships_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+require 'flapjack-diner'
+
+describe Flapjack::Diner::Relationships, :pact => true do
+
+  before(:each) do
+    Flapjack::Diner.base_uri('localhost:19081')
+    Flapjack::Diner.logger = nil
+  end
+
+  it 'adds a tag to a check' do
+    flapjack.given("a check and a tag exist").
+      upon_receiving("a POST request adding a tag to a check").
+      with(:method => :post, :path => "/checks/#{check_data[:id]}/relationships/tags",
+           :headers => {'Content-Type' => 'application/vnd.api+json'},
+           :body => {:data => [{:id => tag_data[:id], :type => 'tag'}]}).
+      will_respond_with(:status => 204,
+                        :body => '')
+
+    result = Flapjack::Diner.create_check_link_tags(check_data[:id], tag_data[:id])
+    expect(result).to be true
+  end
+
+  it 'adds two tags to a check' do
+    flapjack.given("a check and two tags exist").
+      upon_receiving("a POST request adding two tags to a check").
+      with(:method => :post, :path => "/checks/#{check_data[:id]}/relationships/tags",
+           :headers => {'Content-Type' => 'application/vnd.api+json'},
+           :body => {:data => [{:id => tag_data[:id], :type => 'tag'},
+                               {:id => tag_2_data[:id], :type => 'tag'}]}).
+      will_respond_with(:status => 204,
+                        :body => '')
+
+    result = Flapjack::Diner.create_check_link_tags(check_data[:id],
+      tag_data[:id], tag_2_data[:id])
+    expect(result).to be true
+  end
+
+  it 'gets tags for a check' do
+    flapjack.given("a check with a tag exists").
+      upon_receiving("a GET request for all tags on a check").
+      with(:method => :get, :path => "/checks/#{check_data[:id]}/tags").
+      will_respond_with(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/vnd.api+json; supported-ext=bulk; charset=utf-8'},
+        :body => {:data => [{:id => tag_data[:id], :type => 'tag'}]})
+
+    result = Flapjack::Diner.check_link_tags(check_data[:id])
+    expect(result).to eq([{:id => tag_data[:id], :type => 'tag'}])
+  end
+
+  it 'gets tags for a check with full tag records' do
+    included_data = [
+      tag_json(tag_data)
+    ]
+
+    flapjack.given("a check with a tag exists").
+      upon_receiving("a GET request for all tags on a check, with full tag records").
+      with(:method => :get,
+           :path => "/checks/#{check_data[:id]}/tags",
+           :query => "include=tags").
+      will_respond_with(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/vnd.api+json; supported-ext=bulk; charset=utf-8'},
+        :body => {:data => [{:id => tag_data[:id], :type => 'tag'}],
+                  :included => included_data})
+
+    result = Flapjack::Diner.check_link_tags(check_data[:id], :include => 'tags')
+    expect(result).to eq([{:id => tag_data[:id], :type => 'tag'}])
+    expect(Flapjack::Diner.context[:included]).to eq('tag' => {tag_data[:id] => resultify(included_data[0])})
+  end
+
+  it 'gets tags for a check with full tag and rule record' do
+    included_data = [
+      tag_json(tag_data),
+      rule_json(rule_data)
+    ]
+
+    flapjack.given("a check with a tag and a rule exists").
+      upon_receiving("a GET request for all tags on a check, with full tag and rule records").
+      with(:method => :get,
+           :path => "/checks/#{check_data[:id]}/tags",
+           :query => 'include=tags.rules').
+      will_respond_with(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/vnd.api+json; supported-ext=bulk; charset=utf-8'},
+        :body => {:data => [{:id => tag_data[:id], :type => 'tag'}],
+                  :included => included_data})
+
+    result = Flapjack::Diner.check_link_tags(check_data[:id], :include => 'rules')
+    expect(result).to eq([{:id => tag_data[:id], :type => 'tag'}])
+    expect(Flapjack::Diner.context[:included]).to eq(
+      'tag'  => {tag_data[:id] => resultify(included_data[0])},
+      'rule' => {rule_data[:id] => resultify(included_data[1])}
+    )
+  end
+
+  it 'updates tags for a check' do
+    flapjack.given("a check and a tag exist").
+      upon_receiving("a PATCH request updating tags for a check").
+      with(:method => :patch, :path => "/checks/#{check_data[:id]}/relationships/tags",
+           :headers => {'Content-Type' => 'application/vnd.api+json'},
+           :body => {:data => [{:id => tag_data[:id], :type => 'tag'}]}).
+      will_respond_with(:status => 204,
+                        :body => '')
+
+    result = Flapjack::Diner.update_check_link_tags(check_data[:id],
+      tag_data[:id])
+    expect(result).to be true
+  end
+
+  it 'clears all tags from a check' do
+    flapjack.given("a check and a tag exist").
+      upon_receiving("a PATCH request clearing tags for a check").
+      with(:method => :patch, :path => "/checks/#{check_data[:id]}/relationships/tags",
+           :headers => {'Content-Type' => 'application/vnd.api+json'},
+           :body => {:data => []}).
+      will_respond_with(:status => 204,
+                        :body => '')
+
+    result = Flapjack::Diner.update_check_link_tags(check_data[:id], [])
+    expect(result).to be true
+  end
+
+  it 'deletes a tag from a check' do
+    flapjack.given("a check with a tag exists").
+      upon_receiving("a DELETE request deleting a tag from a check").
+      with(:method => :delete, :path => "/checks/#{check_data[:id]}/relationships/tags",
+           :headers => {'Content-Type' => 'application/vnd.api+json'},
+           :body => {:data => [{:id => tag_data[:id], :type => 'tag'}]}).
+      will_respond_with(:status => 204,
+                        :body => '')
+
+    result = Flapjack::Diner.delete_check_link_tags(check_data[:id],
+      tag_data[:id])
+    expect(result).to be true
+  end
+
+  it 'deletes two tags from a check' do
+    flapjack.given("a check with two tags exists").
+      upon_receiving("a DELETE request deleting two tags from a check").
+      with(:method => :delete, :path => "/checks/#{check_data[:id]}/relationships/tags",
+           :headers => {'Content-Type' => 'application/vnd.api+json'},
+           :body => {:data => [{:id => tag_data[:id], :type => 'tag'},
+                               {:id => tag_2_data[:id], :type => 'tag'}]}).
+      will_respond_with(:status => 204,
+                        :body => '')
+
+    result = Flapjack::Diner.delete_check_link_tags(check_data[:id],
+      tag_data[:id], tag_2_data[:id])
+    expect(result).to be true
+  end
+
+  it 'gets the contact for a medium' do
+    flapjack.given("a contact with a medium exists").
+      upon_receiving("a GET request for a medium's contact").
+      with(:method => :get, :path => "/media/#{email_data[:id]}/contact").
+      will_respond_with(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/vnd.api+json; supported-ext=bulk; charset=utf-8'},
+        :body => {:data => {:id => contact_data[:id], :type => 'contact'}})
+
+    result = Flapjack::Diner.medium_link_contact(email_data[:id])
+    expect(result).to eq(:id => contact_data[:id], :type => 'contact')
+  end
+
+  it "doesn't duplicate linked data references in included data" do
+    resp_check = check_json(check_data)
+    resp_check[:relationships] = {
+      :current_state => {
+        :data => {:type => 'state', :id => state_data[:id]}
+      },
+      :latest_notifications => {
+        :data => [{:type => 'state', :id => state_data[:id]}]
+      }
+    }
+
+    sd = state_data.delete_if {|k, _| [:created_at, :updated_at].include?(k)}
+
+    included_data = [
+      resp_check,
+      state_json(sd)
+    ]
+
+    flapjack.given("a check with a tag, current state and a latest notification exists").
+      upon_receiving("a GET request for a check (via tag)'s state and notifications").
+      with(:method => :get,
+           :path => "/tags/#{tag_data[:id]}/checks",
+           :query => 'include=checks.current_state%2Cchecks.latest_notifications').
+      will_respond_with(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/vnd.api+json; supported-ext=bulk; charset=utf-8'},
+        :body => {
+          :data => [
+            {:id => check_data[:id], :type => 'check'},
+          ],
+          :included => included_data
+        })
+
+    result = Flapjack::Diner.tag_link_checks(tag_data[:id],
+      :include => ['checks.current_state', 'checks.latest_notifications'])
+    expect(result).to eq([
+      {:id => check_data[:id], :type => 'check'}
+    ])
+    expect(Flapjack::Diner.context[:included]).to eq(
+      'check' => {check_data[:id] => resultify(resp_check)},
+      'state' => {sd[:id] => resultify(state_json(sd))}
+    )
+  end
+
+end