rdstation-ruby-client 1.2.1 → 2.0.0

data/lib/rdstation/contacts.rb

@@ -3,9 +3,9 @@ module RDStation
   # More info: https://developers.rdstation.com/pt-BR/reference/contacts
   class Contacts
     include HTTParty
-
-    def initialize(auth_token)
-      @auth_token = auth_token
+    
+    def initialize(authorization_header:)
+      @authorization_header = authorization_header
     end
 
     #
@@ -13,12 +13,12 @@ module RDStation
     #   The unique uuid associated to each RD Station Contact.
     #
     def by_uuid(uuid)
-      response = self.class.get(base_url(uuid), headers: required_headers)
+      response = self.class.get(base_url(uuid), headers: @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
     def by_email(email)
-      response = self.class.get(base_url("email:#{email}"), headers: required_headers)
+      response = self.class.get(base_url("email:#{email}"), headers: @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
@@ -34,7 +34,7 @@ module RDStation
     # :website
     # :tags
     def update(uuid, contact_hash)
-      response = self.class.patch(base_url(uuid), :body => contact_hash.to_json, :headers => required_headers)
+      response = self.class.patch(base_url(uuid), :body => contact_hash.to_json, :headers => @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
@@ -48,7 +48,7 @@ module RDStation
     #
     def upsert(identifier, identifier_value, contact_hash)
       path = "#{identifier}:#{identifier_value}"
-      response = self.class.patch(base_url(path), body: contact_hash.to_json, headers: required_headers)
+      response = self.class.patch(base_url(path), body: contact_hash.to_json, headers: @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
@@ -57,9 +57,5 @@ module RDStation
     def base_url(path = "")
       "https://api.rd.services/platform/contacts/#{path}"
     end
-
-    def required_headers
-      { "Authorization" => "Bearer #{@auth_token}", "Content-Type" => "application/json" }
-    end
   end
 end

data/lib/rdstation/error.rb

@@ -1,5 +1,4 @@
 module RDStation
-
   class Error < StandardError
     attr_reader :details, :http_status, :headers, :body
 
@@ -8,23 +7,31 @@ module RDStation
       message = details['error_message']
       raise ArgumentError, 'The details hash must contain an error message' unless message
 
-      # Those three arguments are kept only for compatibility reasons.
-      # They aren't needed since we can get them directly in the details hash.
-      # Consider removing them when update the major version.
-      @http_status = details['http_status']
-      @headers = details['headers']
-      @body = details['body']
-
       super(message)
     end
 
-    class ConflictingField < Error; end
-    class Default < Error; end
-    class ExpiredAccessToken < Error; end
-    class ExpiredCodeGrant < Error; end
-    class InvalidCredentials < Error; end
-    class InvalidEventType < Error; end
-    class ResourceNotFound < Error; end
+    class BadRequest < Error; end
     class Unauthorized < Error; end
+    class Forbidden < Error; end
+    class NotFound < Error; end
+    class MethodNotAllowed < Error; end
+    class NotAcceptable < Error; end
+    class Conflict < Error; end
+    class UnsupportedMediaType < Error; end
+    class UnprocessableEntity < Error; end
+    class InternalServerError < Error; end
+    class NotImplemented < Error; end
+    class BadGateway < Error; end
+    class ServiceUnavailable < Error; end
+    class ServerError < Error; end
+
+    # 400 - Bad Request
+    class ConflictingField < BadRequest; end
+    class InvalidEventType < BadRequest; end
+
+    # 401 - Unauthorized
+    class ExpiredAccessToken < Unauthorized; end
+    class ExpiredCodeGrant < Unauthorized; end
+    class InvalidCredentials < Unauthorized; end
   end
 end

data/lib/rdstation/error_handler.rb

@@ -1,37 +1,42 @@
 require_relative 'error/formatter'
-require_relative 'error_handler/conflicting_field'
-require_relative 'error_handler/default'
-require_relative 'error_handler/expired_access_token'
-require_relative 'error_handler/expired_code_grant'
-require_relative 'error_handler/invalid_credentials'
-require_relative 'error_handler/invalid_event_type'
-require_relative 'error_handler/resource_not_found'
+require_relative 'error_handler/bad_request'
 require_relative 'error_handler/unauthorized'
 
 module RDStation
   class ErrorHandler
-    ERROR_TYPES = [
-      ErrorHandler::ConflictingField,
-      ErrorHandler::ExpiredAccessToken,
-      ErrorHandler::ExpiredCodeGrant,
-      ErrorHandler::InvalidCredentials,
-      ErrorHandler::InvalidEventType,
-      ErrorHandler::ResourceNotFound,
-      ErrorHandler::Unauthorized,
-      ErrorHandler::Default
-    ].freeze
-
     def initialize(response)
       @response = response
+      @code = response.code
     end
 
-    def raise_errors
-      error_types.each(&:raise_error)
+    def raise_error
+      raise error_class, array_of_errors.first if error_class < RDStation::Error
+
+      error_class.new(array_of_errors).raise_error
     end
 
     private
 
-    attr_reader :response
+    attr_reader :response, :code
+
+    def error_class
+      case code
+      when 400      then RDStation::ErrorHandler::BadRequest
+      when 401      then RDStation::ErrorHandler::Unauthorized
+      when 403      then RDStation::Error::Forbidden
+      when 404      then RDStation::Error::NotFound
+      when 405      then RDStation::Error::MethodNotAllowed
+      when 406      then RDStation::Error::NotAcceptable
+      when 409      then RDStation::Error::Conflict
+      when 415      then RDStation::Error::UnsupportedMediaType
+      when 422      then RDStation::Error::UnprocessableEntity
+      when 500      then RDStation::Error::InternalServerError
+      when 501      then RDStation::Error::NotImplemented
+      when 502      then RDStation::Error::BadGateway
+      when 503      then RDStation::Error::ServiceUnavailable
+      when 500..599 then RDStation::Error::ServerError
+      end
+    end
 
     def array_of_errors
       error_formatter.to_array.map do |error|
@@ -39,10 +44,6 @@ module RDStation
       end
     end
 
-    def error_types
-      ERROR_TYPES.map { |error_type| error_type.new(array_of_errors) }
-    end
-
     def response_errors
       JSON.parse(response.body)
     end
@@ -55,7 +56,7 @@ module RDStation
       {
         'headers' => response.headers,
         'body' => JSON.parse(response.body),
-        'http_status' => response.code
+        'http_status' => response.code,
       }
     end
   end

data/lib/rdstation/error_handler/bad_request.rb

@@ -0,0 +1,30 @@
+require_relative 'conflicting_field'
+require_relative 'invalid_event_type'
+
+module RDStation
+  class ErrorHandler
+    class BadRequest
+      BAD_REQUEST_ERRORS = [
+        ErrorHandler::ConflictingField,
+        ErrorHandler::InvalidEventType,
+      ].freeze
+
+      def initialize(array_of_errors)
+        @array_of_errors = array_of_errors
+      end
+
+      def raise_error
+        error_classes.each(&:raise_error)
+        raise RDStation::Error::BadRequest, @array_of_errors.first
+      end
+
+      private
+
+      def error_classes
+        BAD_REQUEST_ERRORS.map do |error|
+          error.new(@array_of_errors)
+        end
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler/unauthorized.rb

@@ -1,23 +1,31 @@
+require_relative 'expired_access_token'
+require_relative 'expired_code_grant'
+require_relative 'invalid_credentials'
+
 module RDStation
   class ErrorHandler
     class Unauthorized
-      attr_reader :errors
-
-      ERROR_CODE = 'UNAUTHORIZED'.freeze
+      UNAUTHORIZED_ERRORS = [
+        ErrorHandler::ExpiredAccessToken,
+        ErrorHandler::ExpiredCodeGrant,
+        ErrorHandler::InvalidCredentials,
+      ].freeze
 
-      def initialize(errors)
-        @errors = errors
+      def initialize(array_of_errors)
+        @array_of_errors = array_of_errors
       end
 
       def raise_error
-        return if unauthorized_errors.empty?
-        raise RDStation::Error::Unauthorized, unauthorized_errors.first
+        error_classes.each(&:raise_error)
+        raise RDStation::Error::Unauthorized, @array_of_errors.first
       end
 
       private
 
-      def unauthorized_errors
-        errors.select { |error| error['error_type'] == ERROR_CODE }
+      def error_classes
+        UNAUTHORIZED_ERRORS.map do |error|
+          error.new(@array_of_errors)
+        end
       end
     end
   end

data/lib/rdstation/events.rb

@@ -4,15 +4,15 @@ module RDStation
 
     EVENTS_ENDPOINT = 'https://api.rd.services/platform/events'.freeze
 
-    def initialize(auth_token)
-      @auth_token = auth_token
+    def initialize(authorization_header:)
+      @authorization_header = authorization_header
     end
 
     def create(payload)
-      response = self.class.post(EVENTS_ENDPOINT, headers: required_headers, body: payload.to_json)
+      response = self.class.post(EVENTS_ENDPOINT, headers: @authorization_header.to_h, body: payload.to_json)
       response_body = JSON.parse(response.body)
       return response_body unless errors?(response_body)
-      RDStation::ErrorHandler.new(response).raise_errors
+      RDStation::ErrorHandler.new(response).raise_error
     end
 
     private
@@ -20,12 +20,5 @@ module RDStation
     def errors?(response_body)
       response_body.is_a?(Array) || response_body['errors']
     end
-
-    def required_headers
-      {
-        'Authorization' => "Bearer #{@auth_token}",
-        'Content-Type'  => 'application/json'
-      }
-    end
   end
 end

data/lib/rdstation/fields.rb

@@ -5,20 +5,15 @@ module RDStation
     include HTTParty
 
     BASE_URL = 'https://api.rd.services/platform/contacts/fields'.freeze
-
-    def initialize(auth_token)
-      @auth_token = auth_token
+    
+    def initialize(authorization_header:)
+      @authorization_header = authorization_header
     end
 
     def all
-      response = self.class.get(BASE_URL, headers: required_headers)
+      response = self.class.get(BASE_URL, headers: @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
-    private
-
-    def required_headers
-      { "Authorization" => "Bearer #{@auth_token}", "Content-Type" => "application/json" }
-    end
   end
 end

data/lib/rdstation/version.rb

@@ -1,3 +1,3 @@
 module RDStation
-  VERSION = '1.2.1'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/rdstation/webhooks.rb

@@ -2,34 +2,34 @@ module RDStation
   class Webhooks
     include HTTParty
 
-    def initialize(auth_token)
-      @auth_token = auth_token
+    def initialize(authorization_header:)
+      @authorization_header = authorization_header
     end
 
     def all
-      response = self.class.get(base_url, headers: required_headers)
+      response = self.class.get(base_url, headers: @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
     def by_uuid(uuid)
-      response = self.class.get(base_url(uuid), headers: required_headers)
+      response = self.class.get(base_url(uuid), headers: @authorization_header.to_h)
       ApiResponse.build(response)
     end
 
     def create(payload)
-      response = self.class.post(base_url, headers: required_headers, body: payload.to_json)
+      response = self.class.post(base_url, headers: @authorization_header.to_h, body: payload.to_json)
       ApiResponse.build(response)
     end
 
     def update(uuid, payload)
-      response = self.class.put(base_url(uuid), headers: required_headers, body: payload.to_json)
+      response = self.class.put(base_url(uuid), headers: @authorization_header.to_h, body: payload.to_json)
       ApiResponse.build(response)
     end
 
     def delete(uuid)
-      response = self.class.delete(base_url(uuid), headers: required_headers)
+      response = self.class.delete(base_url(uuid), headers: @authorization_header.to_h)
       return webhook_deleted_message unless response.body
-      RDStation::ErrorHandler.new(response).raise_errors
+      RDStation::ErrorHandler.new(response).raise_error
     end
 
     private
@@ -41,9 +41,5 @@ module RDStation
     def base_url(path = '')
       "https://api.rd.services/integrations/webhooks/#{path}"
     end
-
-    def required_headers
-      { 'Authorization' => "Bearer #{@auth_token}", 'Content-Type' => 'application/json' }
-    end
   end
 end

data/rdstation-ruby-client.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.0.0'
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency 'rspec'

data/spec/lib/rdstation-ruby-client_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe RDStation do
     let(:rdstation_client) { RDStation::Client.new('token','private' ) }
     let(:lead_email) { "iginosms@gmail.com" }
-    let(:amount) { 300}
+    let(:amount) { 300 }
 
 
   context "#change_lead_status" do

data/spec/lib/rdstation/authorization_header_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::AuthorizationHeader do
+  
+  describe ".initialize" do
+    context "when access_token is nil" do
+      it "raises an error" do
+        expect do
+          described_class.new(access_token: nil)
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+  
+  describe "#to_h" do
+    let(:access_token) { 'access_token' }
+    
+    it "generates the correct header" do
+      header = described_class.new(access_token: access_token).to_h
+      expect(header['Authorization']).to eq "Bearer #{access_token}"
+      expect(header['Content-Type']).to eq "application/json"
+    end
+  end
+end

data/spec/lib/rdstation/client_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::Client do
+  context "when access_token is given" do
+    let(:access_token) { 'access_token' }
+    let(:client) { described_class.new(access_token: access_token) }
+    let(:mock_authorization_header) { double(RDStation::AuthorizationHeader) }
+
+    before { allow(RDStation::AuthorizationHeader).to receive(:new).and_return mock_authorization_header }
+
+    it 'returns Contacts endpoint' do
+      expect(RDStation::Contacts).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(client.contacts).to be_instance_of RDStation::Contacts
+    end
+
+    it 'returns Events endpoint' do
+      expect(RDStation::Events).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(client.events).to be_instance_of RDStation::Events
+    end
+
+    it 'returns Fields endpoint' do
+      expect(RDStation::Fields).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(client.fields).to be_instance_of RDStation::Fields
+    end
+
+    it 'returns Webhooks endpoint' do
+      expect(RDStation::Webhooks).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(client.webhooks).to be_instance_of RDStation::Webhooks
+    end
+  end
+
+  context "when access_token isn't given" do
+    it "raises an ArgumentError exception" do
+      expect{ described_class.new(access_token: nil) }.to raise_error(ArgumentError)
+    end
+  end
+end