xcal-parktronic 0.0.1 → 1.0.0

data/lib/xcal/parktronic/routes/nested/metric_values.rb

@@ -0,0 +1,35 @@
+module Xcal
+  module Parktronic
+    module Routes
+      module Nested
+
+        module MetricValues
+
+          # Fetches metric_values for the specific metric
+          # Executed as a method chain from the GenericResponse object
+          #
+          # Call example:
+          #   metric(id).get_metric_values(page: 2, per_page: 4)
+          #
+          # Accepted attributes:
+          #   +page+ page number, defaults to 1
+          #   +per_page+ per page value, defaults to 100
+          def get_paged_metric_values(args = {})
+            args.merge!(:access_token => client.access_token)
+            response = client.http.get("/#{client.api_version}/metrics/#{id}/metric_values?#{URI.encode_www_form(args)}")
+
+            generic_response = Xcal::Parktronic::GenericResponse.new(response.body, client)
+            if response.code == '200' && generic_response.has_key?(:metric_values)
+              generic_response.metric_values.map(&:metric_value)
+            else
+              generic_response
+            end
+          end
+          alias :get_metric_values :get_paged_metric_values
+
+        end
+
+      end
+    end
+  end
+end

data/lib/xcal/parktronic/routes/outages.rb

@@ -0,0 +1,34 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module Outages
+
+        # Fetches outages
+        #
+        # ==== Parameters
+        # * +page+ page number, defaults to 1
+        # * +per_page+ per page value, defaults to 100
+        #
+        # ==== Examples
+        #   api.get_paged_outages
+        #   api.outages
+        def get_paged_outages(args = {})
+          args.merge!(access_token: access_token)
+          response = http.get("/#{api_version}/outages?#{URI.encode_www_form(args)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          if response.code == '200' && generic_response.has_key?(:high_impact_incidents)
+            generic_response.high_impact_incidents.map { |incident| Xcal::Parktronic::GenericResponse.new(incident.high_impact_incident, self) }
+          else
+            generic_response
+          end
+
+          # TODO Add caching
+        end
+        alias :outages :get_paged_outages
+      end
+
+    end
+  end
+end

data/lib/xcal/parktronic/routes/stack_changes.rb

@@ -0,0 +1,53 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module StackChanges
+
+        # Fetches stack changes
+        #
+        # ==== Parameters
+        # * +element+ stack change element
+        # * +time_range+ time range interval
+        # * +page+ page number, defaults to 1
+        # * +per_page+ per page value, defaults to 100
+        #
+        # ==== Examples
+        #   api.get_paged_stack_changes
+        #   api.stack_changes(element: 'TEST', page: 1, per_page: 5)
+        # TODO FIX time_range param, need pass it as json
+        def get_paged_stack_changes(args = {})
+          args.merge!(access_token: access_token)
+          response = http.get("/#{api_version}/stack_changes?#{URI.encode_www_form(args)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          if response.code == '200' && generic_response.has_key?(:stack_changes)
+            generic_response.stack_changes.map { |stack| Xcal::Parktronic::GenericResponse.new(stack.stack_change, self) }
+          else
+            generic_response
+          end
+
+          # TODO Add caching
+        end
+        alias :stack_changes :get_paged_stack_changes
+
+
+        # Posts new stack change
+        #
+        # ==== Parameters
+        # * +stack_change+ hash of Stack Change data.
+        #
+        # ==== Examples
+        #   api.post_stack_change( ticket_id: 'CHANGE-14725', ticket_summary: 'test', element: 'TEST' )
+        def post_stack_change(stack_change = {})
+          request = Net::HTTP::Post.new("/#{api_version}/stack_changes", 'Content-Type' => 'application/json')
+          request.body = { access_token: access_token, stack_change: stack_change }.to_json
+          response = http.start { |net| net.request(request) }
+
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+      end
+
+    end
+  end
+end

data/lib/xcal/parktronic/version.rb

@@ -1,5 +1,5 @@
 module Xcal
   module Parktronic
-    VERSION = "0.0.1"
+    VERSION = '1.0.0'
   end
 end

data/spec/lib/xcal/parktronic/api_client_spec.rb

@@ -9,6 +9,16 @@ describe Xcal::Parktronic::ApiClient do
     let(:api_https_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'https://localhost:3000/v1', access_token: 'fake_access_token') }
     let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://', access_token: 'fake_access_token') }
 
+    it 'should initialize correctly initialize' do
+      api = Xcal::Parktronic::ApiClient.new(endpoint: 'http://localhost:3000/v1', access_token: 'access_token')
+      expect(api.host).to eql('localhost')
+      expect(api.access_token).to eql('access_token')
+
+      api = Xcal::Parktronic::ApiClient.new('endpoint' => 'http://localhost:3000/v1', 'access_token' => 'access_token')
+      expect(api.host).to eql('localhost')
+      expect(api.access_token).to eql('access_token')
+    end
+
     it 'should initialize correctly and provide access to arguments' do
       expect(api_http_client.host).to eql('localhost')
       expect(api_http_client.port).to eql(3000)
@@ -25,9 +35,9 @@ describe Xcal::Parktronic::ApiClient do
       expect(api_https_client.http.use_ssl?).to eql(true)
 
       # proxy
-      expect(api_http_client.http.proxy?).to eql(nil)
+      expect([false, nil]).to include(api_http_client.http.proxy?)
       expect(api_http_proxy_client.http.proxy?).to eql(true)
     end
   end
 
-end
+end

data/spec/lib/xcal/parktronic/routes/alarms_route_spec.rb

@@ -10,7 +10,7 @@ describe Xcal::Parktronic::ApiClient do
     it 'should not be allowed without access_token' do
       expect{ api_invalid_client.get_paged_alarms(page: 1, per_page: 10) }.not_to raise_error
       expect{ api_invalid_client.get_alarm(1) }.not_to raise_error
-      expect{ api_invalid_client.post_alarm({}, {}) }.not_to raise_error
+      expect{ api_invalid_client.post_alarm({}) }.not_to raise_error
     end
 
     context 'getting' do
@@ -53,5 +53,20 @@ describe Xcal::Parktronic::ApiClient do
       end
     end
 
+    context 'alarm events' do
+      it 'should give an appropriate list of alarms' do
+        alarm = api_http_client.get_alarm(2)
+
+        expect{alarm.get_events.first.id}.not_to raise_error
+        expect(alarm.get_events.first.id).to eql(73)
+        expect(alarm.get_events.last.id).to eql(370)
+      end
+    end
+
+    describe '#get_event_tags' do
+      it 'should get tags of alarm' do
+        expect{ api_http_client.get_alarm_tags(1) }.not_to raise_error
+      end
+    end
   end
 end

data/spec/lib/xcal/parktronic/routes/command_notifications_routes_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Xcal::Parktronic::ApiClient do
+
+  let(:api_http_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock', access_token: 'access_token') }
+  let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock') }
+
+  context 'remote commands routes' do
+
+    it 'is not allowed without access_token' do
+      expect{ api_invalid_client.get_paged_command_notifications(page: 1, per_page: 5) }.not_to raise_error
+      expect{ api_invalid_client.update_command_notification(1) }.not_to raise_error
+    end
+
+    context 'getting' do
+      it 'responds with the correct set of remote commands' do
+        command_notifications = api_http_client.get_paged_command_notifications(page: 1, per_page: 5)
+
+        expect(command_notifications.first.command_id.to_s).to eql('1')
+        expect(command_notifications.last.command_id.to_s).to eql('5')
+      end
+    end
+
+    context 'setting' do
+      it 'should update command notification by id' do
+        expect{ api_http_client.update_command_notification() }.to raise_error
+        expect{ api_http_client.update_command_notification(1) }.not_to raise_error
+      end
+    end
+
+  end
+end

data/spec/lib/xcal/parktronic/routes/event_history_items_routes_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Xcal::Parktronic::ApiClient do
+
+  let(:api_http_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock', access_token: 'access_token') }
+  let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock') }
+
+  context 'events history routes' do
+
+    it 'is not allowed without access_token' do
+      expect{ api_invalid_client.get_paged_event_history_items(page: 1, per_page: 5) }.not_to raise_error
+    end
+
+    context 'getting' do
+      it 'responds with the correct set of events history' do
+        event_history_items = api_http_client.get_paged_event_history_items(page: 1, per_page: 5)
+        expect(event_history_items.first.event_id.to_s).to eql('1')
+        expect(event_history_items.first.incident_status).to eql('Resolved')
+        expect(event_history_items.first.initiated_at).to eql('2013-12-30T21:03:39.000Z')
+
+
+        expect(event_history_items.last.event_id.to_s).to eql('2')
+        expect(event_history_items.last.incident_status).to eql('ACKNOWLEDGED')
+        expect(event_history_items.last.initiated_at).to eql('2013-12-26T21:03:39.000Z')
+      end
+    end
+  end
+end

data/spec/lib/xcal/parktronic/routes/events_route_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Xcal::Parktronic::ApiClient do
+
+  let(:api_http_client)   { Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock', access_token: 'access_token') }
+  let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock') }
+
+  context 'events route' do
+
+    describe '#get_event' do
+      it 'should get event by id' do
+        expect{ api_http_client.get_event(1) }.not_to raise_error
+
+        event = api_http_client.get_event(1)
+        expect(event.service_impacted).to eql('Redis Hitrate')
+      end
+    end
+
+    describe '#update_event' do
+      it 'should update event by id' do
+        expect{ api_http_client.update_event() }.to raise_error
+        expect{ api_http_client.update_event(1, service_impacted: 'test') }.not_to raise_error
+      end
+    end
+
+    describe '#get_event_tags' do
+      it 'should get tags of event' do
+        expect{ api_http_client.get_event_tags(1) }.not_to raise_error
+      end
+    end
+  end
+
+end

data/spec/lib/xcal/parktronic/routes/metrics_routes_spec.rb

@@ -1,49 +1,92 @@
-#require 'spec_helper'
-#
-#describe Xcal::Parktronic::ApiClient do
-#
-#  let(:api_http_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock', access_token: 'fake_access_token') }
-#  let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock') }
-#
-#  context 'alarms route' do
-#
-#    it 'should not be allowed without access_token' do
-#      response = api_invalid_client.get_paged_alarms(page: 1, per_page: 10)
-#
-#      expect(response.code).to eql('403')
-#      expect{ JSON.load(response.body) }.not_to raise_error
-#    end
-#
-#    it 'should respond with the correct set of alarms' do
-#      response = api_http_client.get_paged_alarms(page: 1, per_page: 10)
-#
-#      expect(response.code).to eql('200')
-#      expect{ JSON.load(response.body) }.not_to raise_error
-#    end
-#
-#    context 'posting' do
-#      let(:alarm) do
-#        { :name => 'alarm name', :originating_system => 'Source System', :impact_level => 'low', :tag_list => %w(taga tagb) }
-#      end
-#      let(:event) do
-#        {
-#            :subject => 'EventSubj',
-#            :description => 'EventDesc',
-#            :host_impacted => 'host',
-#            :initiated_at => '2013-11-22T01:00:24Z',
-#            :service_impacted => 'EventSvc',
-#            :incident_status => 'CRITICAL'
-#        }
-#      end
-#
-#      it 'should post alarms successfully' do
-#        response = api_http_client.post_alarm({ :alarm => alarm, :events => [event] })
-#
-#        expect(response.code).to eql('201')
-#        expect{ JSON.load(response.body) }.not_to raise_error
-#      end
-#    end
-#
-#
-#  end
-#end
+require 'spec_helper'
+
+describe Xcal::Parktronic::ApiClient do
+
+  let(:api_http_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock', access_token: 'access_token') }
+  let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock') }
+
+  context 'metrics route' do
+
+    it 'should not be allowed without access_token' do
+      expect{ api_invalid_client.get_paged_metrics(page: 1, per_page: 10) }.not_to raise_error
+      expect{ api_invalid_client.get_metric(1) }.not_to raise_error
+      expect{ api_invalid_client.post_metric({}) }.not_to raise_error
+    end
+
+    context 'getting' do
+      it 'should respond with the correct set of metrics' do
+        metrics = nil
+        expect{ metrics = api_http_client.get_paged_metrics(page: 1, per_page: 10) }.not_to raise_error
+        expect(metrics.first.id.to_s).to eql('7')
+        expect(metrics.first.name).to eql('Metric 1')
+
+        expect(metrics.last.id.to_s).to eql('16')
+        expect(metrics.last.name).to eql('Metric 10')
+      end
+
+      it 'should respond with single metric' do
+        metric = nil
+        expect{ metric = api_http_client.get_metric(2) }.not_to raise_error
+
+        expect(metric.id.to_s).to eql('7')
+      end
+    end
+
+    context 'posting' do
+      let(:metric) do
+        { :name => 'metric name', :originating_system => 'Source System', :impact_level => 'low', :tag_list => %w(taga tagb) }
+      end
+      let(:metric_value) do
+        {
+            value: 22,
+            created_at: '2013-07-24T13:21:16Z',
+            custom_timestamp: nil,
+        }
+      end
+      let(:device_error) do
+        {
+          value: 5,
+          created_at: '2013-07-24T13:21:16Z',
+          custom_timestamp: nil,
+          value_groups: [
+              {
+                  group_type: 'Code',
+                  group_value: 33
+              },
+              {
+                  group_type: 'software_stack',
+                  group_value: 'stack'
+              }
+          ]
+        }
+      end
+
+      it 'should post metrics successfully' do
+        send_data = { :metric => metric, :metric_values => [metric_value], :device_error => device_error }
+        expect{ api_http_client.post_metric(send_data) }.not_to raise_error
+        expect{ api_invalid_client.post_metric(send_data) }.not_to raise_error
+      end
+    end
+
+    context 'metric metric_values' do
+      it 'should give an appropriate list of alarms' do
+        metric = api_http_client.get_metric(2)
+
+        expect{metric.get_metric_values.first.value}.not_to raise_error
+        expect(metric.get_metric_values.first.value).to eql('5.339')
+        expect(metric.get_metric_values.last.value).to eql('4.880')
+      end
+    end
+
+    context 'metric device_errors' do
+      it 'should give an appropriate list of alarms' do
+        metric = api_http_client.get_metric(2)
+
+        expect{metric.get_device_errors.first.value}.not_to raise_error
+        expect(metric.get_device_errors.first.value).to eql(53)
+        expect(metric.get_device_errors.last.value).to eql(32)
+      end
+    end
+
+  end
+end

data/spec/lib/xcal/parktronic/routes/nested/alarm_actions_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Xcal::Parktronic::ApiClient do
+
+  let(:api_http_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock', access_token: 'access_token') }
+  let(:api_invalid_client){ Xcal::Parktronic::ApiClient.new(endpoint: 'http://api.mock') }
+
+  context 'alarms route' do
+    describe '#get_alarm_actions' do
+      it 'should return alarm_actions for alarm' do
+        expect{ api_http_client.get_alarm(2).get_alarm_actions}.not_to raise_error
+        expect{ api_http_client.get_alarm(22).get_alarm_actions}.not_to raise_error
+      end
+    end
+
+    describe '#get_alarm_actions' do
+      it 'should return alarm_action for alarm' do
+        expect{ api_http_client.get_alarm(2).get_alarm_action(2)}.not_to raise_error
+
+        alarm_action = api_http_client.get_alarm(2).get_alarm_action(2)
+        expect(alarm_action.action_id).to eql(1)
+        expect(alarm_action.rule.attribute).to eql('aggregated_count')
+        expect(alarm_action.rule.operator).to eql('NOT IN')
+        expect(alarm_action.rule.value).to eql('OPEN')
+      end
+    end
+
+    describe '#post_alarm_action' do
+      it 'should create alarm_action for alarm' do
+        alarm_action = api_http_client.get_alarm(2).get_alarm_action(2)
+        alarm_action_params = {alarm_id: 2, action_id: 1,rule: {:attribute=>"aggregated_count", :operator=>"NOT IN", :value=>"OPEN"}}
+
+        expect{ api_http_client.get_alarm(2).post_alarm_action(alarm_action_params)}.not_to raise_error
+        expect{ alarm_action.post_alarm_action(alarm_action_params)}.not_to raise_error
+      end
+    end
+
+    describe '#update_alarm_action' do
+      it 'should update alarm_action' do
+        alarm_action = api_http_client.get_alarm(2).get_alarm_action(2)
+        alarm_action_params = {alarm_id: 2, action_id: 1,rule: {:attribute=>"aggregated_count", :operator=>"IN", :value=>"NEW"}}
+
+        expect{ api_http_client.get_alarm(2).update_alarm_action(1, alarm_action_params) }.not_to raise_error
+        expect{ alarm_action.update_alarm_action(1, alarm_action_params) }.not_to raise_error
+      end
+    end
+
+    describe '#set_position' do
+      it 'should update position for alarm_action' do
+        alarm_action = api_http_client.get_alarm(2).get_alarm_action(2)
+
+        expect{ api_http_client.get_alarm(2).set_position(1, 10) }.not_to raise_error
+        expect{ alarm_action.set_position(1, 10) }.not_to raise_error
+      end
+    end
+
+  end
+end