pingdom_client_v3 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad56c767c43aa546a4cde464b65c52e9796fb3a31fb5a8a2e6c93e831389012c
+  data.tar.gz: 0f044f192dc6620dfb75c92f9e96783a269b845724ebac083e857a39c0c187ab
+SHA512:
+  metadata.gz: 1e2a33899942e06db747fa24502dbf3cc6152d8cb0f62d9f1ee23d15a28bcf854ae0162e078bf20e6b105124615537355344b1a4f7fa88fc9bac18391fffbf07
+  data.tar.gz: 6a3b347d3368fce6a5a0cf538e302a5cfa18f6e1cfeeb4caaad3d9fb1341e5c562f5d4dc0827e8abbfe8b849d8ca7e030c0c4eea027b1d7644ffe0c38a303b06

data/README.md

@@ -0,0 +1,41 @@
+# PingdomClientV3
+
+Lightweight ruby gem for connecting to Pingdom's API V3.
+
+## About Pingdom
+
+[https://www.pingdom.com/](https://www.pingdom.com/)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pingdom_client_v3'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pingdom_client_v3
+
+## Usage
+
+```
+client = PingdomClientV3::Client.new('api-key');
+
+
+# test connection
+
+response = client.checks #=> PingdomClientV3::Response
+response.success? #=> Boolean
+checks = response.response_object['checks'] #=> Array
+checks.first.name #=> 'you check name'
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pingdom_client_v3"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/client.rb

@@ -0,0 +1,24 @@
+require 'rest-client'
+
+module PingdomClientV3
+  class Client
+    def initialize(api_url='https://api.pingdom.com/api/3.1', api_token)
+      @api_url = api_url
+      @api_token = api_token
+    end
+
+    def check
+      @pool ||= PingdomClientV3::Resources::Check.new(self)
+    end
+
+    def resource_caller
+      PingdomClientV3::ResourceCaller.new(http_resource)
+    end
+
+    private
+
+    def http_resource
+      RestClient::Resource.new(@api_url, headers: { 'Authorization' => "Bearer #{@api_token}" })
+    end
+  end
+end

data/lib/pingdom_client_v3/client.rb

@@ -0,0 +1,24 @@
+require 'rest-client'
+
+module PingdomClientV3
+  class Client
+    def initialize(api_token, api_url='https://api.pingdom.com/api/3.1')
+      @api_token = api_token
+      @api_url = api_url
+    end
+
+    def check
+      @check ||= PingdomClientV3::Resources::Check.new(self)
+    end
+
+    def resource_caller
+      PingdomClientV3::ResourceCaller.new(http_resource)
+    end
+
+    private
+
+    def http_resource
+      RestClient::Resource.new(@api_url, headers: { 'Authorization' => "Bearer #{@api_token}" })
+    end
+  end
+end

data/lib/pingdom_client_v3/custom_exception.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module PingdomClientV3
+  class CustomException < StandardError
+    attr_reader :http_response, :original_exception, :error_message
+
+    def initialize(original_exception)
+      @original_exception = original_exception
+      @http_response = @original_exception.response if @original_exception.respond_to?(:response)
+      @error_message = parsed_response if @http_response
+      super(@original_exception.to_s)
+    end
+
+    private
+
+    def parsed_response
+      @json_error_parser ||= parse_json_body
+    end
+
+    def parse_json_body
+      JSON.load(@http_response.body)
+    rescue
+      ''
+    end
+  end
+
+  class ConnectionError < CustomException; end
+  class StandardError < CustomException; end
+  class BadResponse < CustomException; end
+end

data/lib/pingdom_client_v3/resource_caller.rb

@@ -0,0 +1,53 @@
+require 'json'
+
+module PingdomClientV3
+  class ResourceCaller
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def get(path)
+      wrap_exception { @resource[path].get }
+    end
+
+    def post(path, payload = {})
+      send_payload(:post, path, payload)
+    end
+
+    def put(path, payload = {})
+      send_payload(:put, path, payload)
+    end
+
+    def patch(path, payload = {})
+      send_payload(:patch, path, payload)
+    end
+
+    def delete(path)
+      wrap_exception { @resource[path].delete }
+    end
+
+    private
+
+    def send_payload(method, path, payload)
+      wrap_exception { @resource[path].send(method, hash_to_json(payload), json_headers) }
+    end
+
+    def hash_to_json(hash)
+      JSON.dump(hash)
+    end
+
+    def json_headers
+      { 'Content-Type' => 'application/json' }
+    end
+
+    def wrap_exception
+      PingdomClientV3::Response.new(yield)
+    rescue RestClient::ExceptionWithResponse => e
+      raise PingdomClientV3::BadResponse.new(e)
+    rescue RestClient::Exception, SocketError => e
+      raise PingdomClientV3::ConnectionError.new(e)
+    rescue => e
+      raise PingdomClientV3::StandardError.new(e)
+    end
+  end
+end

data/lib/pingdom_client_v3/resources/base_resource.rb

@@ -0,0 +1,14 @@
+module PingdomClientV3
+  module Resources
+    class BaseResource
+      extend Forwardable
+
+      def_delegators :@resource_caller, :get, :post, :put, :delete, :patch
+
+      def initialize(client)
+        @resource_caller = client.resource_caller
+      end
+    end
+  end
+end
+

data/lib/pingdom_client_v3/resources/check.rb

@@ -0,0 +1,21 @@
+module PingdomClientV3
+  module Resources
+    class Check < BaseResource
+      def index(params = {})
+        get("/checks?#{URI.encode_www_form(params)}")
+      end
+
+      def show(check_id)
+        get("/checks/#{check_id}")
+      end
+
+      def create(payload)
+        post("/checks", payload)
+      end
+
+      def destroy(check_id)
+        delete("/checks/#{check_id}")
+      end
+    end
+  end
+end

data/lib/pingdom_client_v3/response.rb

@@ -0,0 +1,54 @@
+require 'json'
+require 'forwardable'
+
+module PingdomClientV3
+  class Response
+    extend Forwardable
+
+    def_delegators :@original_response, :code, :request, :headers
+
+    def initialize(original_response)
+      @original_response = original_response
+    end
+
+    def success?
+      success_codes.include?(code)
+    end
+
+    def failure?
+      !success?
+    end
+
+    def body
+      @body ||= parse_json_safe(original_body)
+    end
+
+    def original_body
+      @original_response.body
+    end
+
+    def response_object
+      @response_object ||= initialize_object(body)
+    end
+
+    private
+
+    def initialize_object(body)
+      if body.is_a?(Array)
+        body.map do |item|
+          PingdomClientV3::ResponseObject.new(item)
+        end
+      else
+        PingdomClientV3::ResponseObject.new(body)
+      end
+    end
+
+    def success_codes
+      200..226
+    end
+
+    def parse_json_safe(json)
+      JSON.load(json)
+    end
+  end
+end

data/lib/pingdom_client_v3/response_object.rb

@@ -0,0 +1,9 @@
+require 'delegate'
+
+module PingdomClientV3
+  class ResponseObject < SimpleDelegator
+    def initialize(attributes)
+      __setobj__(attributes)
+    end
+  end
+end

data/lib/pingdom_client_v3/version.rb

@@ -0,0 +1,3 @@
+module PingdomClientV3
+  VERSION = "0.0.1"
+end

data/lib/pingdom_client_v3.rb

@@ -0,0 +1,11 @@
+require 'pingdom_client_v3/version'
+require 'pingdom_client_v3/custom_exception'
+require 'pingdom_client_v3/response_object'
+require 'pingdom_client_v3/response'
+require 'pingdom_client_v3/resource_caller'
+require 'pingdom_client_v3/resources/base_resource'
+require 'pingdom_client_v3/resources/check'
+require 'pingdom_client_v3/client'
+
+module PingdomClientV3
+end

data/spec/pingdom_client_v3/client_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+module PingdomClientV3
+  RSpec.describe Client do
+    include_context :pingdom_client
+
+    subject { pingdom_client }
+
+    describe '#check' do
+      specify { expect(subject.check).to be_a PingdomClientV3::Resources::Check }
+
+      specify do
+        expect(PingdomClientV3::Resources::Check).to receive(:new).with(subject)
+        subject.check
+      end
+    end
+
+    describe '#resource_caller' do
+      let(:resource) { double(:resource) }
+
+      before do
+        allow(RestClient::Resource).to receive(:new).with(pingdom_api_url, headers: { 'Authorization' => "Bearer #{pingdom_api_key}" }).and_return(resource)
+      end
+
+      specify do
+        expect(PingdomClientV3::ResourceCaller).to receive(:new).with(resource).and_call_original
+        expect(subject.resource_caller).to be_a PingdomClientV3::ResourceCaller
+      end
+    end
+  end
+end

data/spec/pingdom_client_v3/custom_exception_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../spec_helper'
+require 'json'
+
+module PingdomClientV3
+  RSpec.describe CustomException do
+    it 'inherits from StandardError' do
+      expect(described_class.superclass).to be ::StandardError
+    end
+
+    subject { described_class.new(original_exception) }
+
+    describe '#original_exception' do
+      let(:original_exception) { double }
+
+      specify { expect(subject.original_exception).to eq original_exception }
+    end
+
+    describe '#http_response' do
+      let(:original_exception) { double(:response => 'a response object') }
+
+      specify { expect(subject.http_response).to eq 'a response object' }
+    end
+
+    describe '#error_message' do
+      let(:original_exception) { double }
+      let(:response) { double }
+      let(:body) { JSON.dump({ :some => 'response' }) }
+
+      before do
+        expect(original_exception).to receive(:response).and_return(response)
+        expect(response).to receive(:body).and_return(body)
+      end
+
+      specify { expect(subject.error_message).to eq({ 'some' => 'response' }) }
+    end
+  end
+end

data/spec/pingdom_client_v3/resource_caller_spec.rb

@@ -0,0 +1,271 @@
+require_relative '../spec_helper'
+
+module PingdomClientV3
+  RSpec.describe ResourceCaller do
+    let(:resource) { double(:resource) }
+
+    subject { described_class.new(resource) }
+
+    describe '#post' do
+      let(:payload) { { :name => 'John' } }
+      let(:json_payload) { JSON.dump(payload) }
+      let(:result) { subject.post('some_path', payload) }
+      let(:post_resource) { double(:post_resource) }
+      let(:headers) { { 'Content-Type' => 'application/json' } }
+
+      context 'when request is successful' do
+        let(:fake_response) { double(:fake_response) }
+
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:post).with(json_payload, headers).and_return(fake_response)
+        end
+
+        it 'returns a PingdomClientV3::Response' do
+          expect(result).to be_a PingdomClientV3::Response
+        end
+      end
+
+      context 'when resource raises a RestClient::ExceptionWithResponse' do
+        let(:http_code) { 422 }
+        let(:exception) { RestClient::ExceptionWithResponse.new }
+
+        before do
+          allow(exception).to receive(:http_code).and_return(http_code)
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:post).with(json_payload, headers).and_raise(exception)
+        end
+
+        it 'raises a PingdomClientV3::BadResponse' do
+          expect { result }.to raise_error PingdomClientV3::BadResponse
+        end
+      end
+
+      context 'when resource raises a RestClient::Exception' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:post).with(json_payload, headers).and_raise(RestClient::Exception.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises a SocketError' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:post).with(json_payload, headers).and_raise(SocketError.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises any other error' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:post).with(json_payload, headers).and_raise(StandardError.new('some_error'))
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::StandardError
+        end
+      end
+    end
+
+    describe '#put' do
+      let(:payload) { { :name => 'John' } }
+      let(:json_payload) { JSON.dump(payload) }
+      let(:result) { subject.put('some_path', payload) }
+      let(:post_resource) { double(:post_resource) }
+      let(:headers) { { 'Content-Type' => 'application/json' } }
+
+      context 'when request is successful' do
+        let(:fake_response) { double(:fake_response) }
+
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:put).with(json_payload, headers).and_return(fake_response)
+        end
+
+        it 'returns a PingdomClientV3::Response' do
+          expect(result).to be_a PingdomClientV3::Response
+        end
+      end
+
+      context 'when resource raises a RestClient::ExceptionWithResponse' do
+        let(:http_code) { 422 }
+        let(:exception) { RestClient::ExceptionWithResponse.new }
+
+        before do
+          allow(exception).to receive(:http_code).and_return(http_code)
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:put).with(json_payload, headers).and_raise(exception)
+        end
+
+        it 'raises a PingdomClientV3::BadResponse' do
+          expect { result }.to raise_error PingdomClientV3::BadResponse
+        end
+      end
+
+      context 'when resource raises a RestClient::Exception' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:put).with(json_payload, headers).and_raise(RestClient::Exception.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises a SocketError' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:put).with(json_payload, headers).and_raise(SocketError.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises any other error' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(post_resource)
+          allow(post_resource).to receive(:put).with(json_payload, headers).and_raise(StandardError.new('some_error'))
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::StandardError
+        end
+      end
+    end
+
+    describe '#get' do
+      let(:result) { subject.get('some_path') }
+      let(:get_resource) { double(:get_resource) }
+
+      context 'when request is successful' do
+        let(:fake_response) { double(:fake_response) }
+
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:get).and_return(fake_response)
+        end
+
+        it 'returns a PingdomClientV3::Response' do
+          expect(result).to be_a PingdomClientV3::Response
+        end
+      end
+
+      context 'when resource raises a RestClient::ExceptionWithResponse' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:get).and_raise(RestClient::ExceptionWithResponse.new)
+        end
+
+        it 'raises a PingdomClientV3::BadResponse' do
+          expect { result }.to raise_error PingdomClientV3::BadResponse
+        end
+      end
+
+      context 'when resource raises a RestClient::Exception' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:get).and_raise(RestClient::Exception.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises a SocketError' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:get).and_raise(SocketError.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises any other error' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:get).and_raise(StandardError.new('some_error'))
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::StandardError
+        end
+      end
+    end
+
+    describe '#delete' do
+      let(:result) { subject.delete('some_path') }
+      let(:get_resource) { double(:get_resource) }
+
+      context 'when request is successful' do
+        let(:fake_response) { double(:fake_response) }
+
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:delete).and_return(fake_response)
+        end
+
+        it 'returns a PingdomClientV3::Response' do
+          expect(result).to be_a PingdomClientV3::Response
+        end
+      end
+
+      context 'when resource raises a RestClient::ExceptionWithResponse' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:delete).and_raise(RestClient::ExceptionWithResponse.new)
+        end
+
+        it 'raises a PingdomClientV3::BadResponse' do
+          expect { result }.to raise_error PingdomClientV3::BadResponse
+        end
+      end
+
+      context 'when resource raises a RestClient::Exception' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:delete).and_raise(RestClient::Exception.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises a SocketError' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:delete).and_raise(SocketError.new)
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::ConnectionError
+        end
+      end
+
+      context 'when resource raises any other error' do
+        before do
+          allow(resource).to receive(:[]).with('some_path').and_return(get_resource)
+          allow(get_resource).to receive(:delete).and_raise(StandardError.new('some_error'))
+        end
+
+        it 'raises a PingdomClientV3::ConnectionError' do
+          expect { result }.to raise_error PingdomClientV3::StandardError
+        end
+      end
+    end
+  end
+end