rdstation-ruby-client 0.1.1 → 1.0.0

data/lib/rdstation/error_handler/expired_code_grant.rb

@@ -0,0 +1,27 @@
+module RDStation
+  class ErrorHandler
+    class ExpiredCodeGrant
+      attr_reader :api_response, :response_headers, :error
+
+      ERROR_CODE = 'EXPIRED_CODE_GRANT'.freeze
+      EXCEPTION_CLASS = RDStation::Error::ExpiredCodeGrant
+
+      def initialize(api_response)
+        @api_response = api_response
+        @error = JSON.parse(api_response.body)['errors']
+        @response_headers = api_response.headers
+      end
+
+      def raise_error
+        return unless expired_code?
+        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+      end
+
+      private
+
+      def expired_code?
+        error['error_type'] == ERROR_CODE
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler/invalid_credentials.rb

@@ -0,0 +1,26 @@
+module RDStation
+  class ErrorHandler
+    class InvalidCredentials
+      attr_reader :api_response, :error
+
+      ERROR_CODE = 'ACCESS_DENIED'.freeze
+      EXCEPTION_CLASS = RDStation::Error::InvalidCredentials
+
+      def initialize(api_response)
+        @api_response = api_response
+        @error = JSON.parse(api_response.body)['errors']
+      end
+
+      def raise_error
+        return unless credentials_errors?
+        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+      end
+
+      private
+
+      def credentials_errors?
+        error['error_type'] == ERROR_CODE
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler/resource_not_found.rb

@@ -0,0 +1,26 @@
+module RDStation
+  class ErrorHandler
+    class ResourceNotFound
+      attr_reader :api_response, :error
+
+      ERROR_CODE = 'RESOURCE_NOT_FOUND'.freeze
+      EXCEPTION_CLASS = RDStation::Error::ResourceNotFound
+
+      def initialize(api_response)
+        @api_response = api_response
+        @error = JSON.parse(api_response.body)['errors']
+      end
+
+      def raise_error
+        return unless resource_not_found?
+        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+      end
+
+      private
+
+      def resource_not_found?
+        error['error_type'] == ERROR_CODE
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler/unauthorized.rb

@@ -0,0 +1,26 @@
+module RDStation
+  class ErrorHandler
+    class Unauthorized
+      attr_reader :api_response, :response_body, :error
+
+      ERROR_CODE = 'UNAUTHORIZED'.freeze
+      EXCEPTION_CLASS = RDStation::Error::Unauthorized
+
+      def initialize(api_response)
+        @api_response = api_response
+        @error = JSON.parse(api_response.body)['errors']
+      end
+
+      def raise_error
+        return unless unauthorized?
+        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+      end
+
+      private
+
+      def unauthorized?
+        error['error_type'] == ERROR_CODE
+      end
+    end
+  end
+end

data/lib/rdstation/fields.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module RDStation
+  # More info: https://developers.rdstation.com/pt-BR/reference/contacts
+  class Fields
+    include HTTParty
+
+    BASE_URL = 'https://api.rd.services/platform/contacts/fields'.freeze
+
+    def initialize(auth_token)
+      @auth_token = auth_token
+    end
+
+    def all
+      response = self.class.get(BASE_URL, headers: required_headers)
+      response_body = JSON.parse(response.body)
+      return response_body unless response_body['errors']
+      RDStation::ErrorHandler.new(response).raise_errors
+    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 = '0.1.1'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/rdstation-ruby-client.gemspec

@@ -21,8 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'vcr'
-  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'webmock', '~> 2.1'
   spec.add_development_dependency 'turn'
 
   spec.add_dependency "httparty", "~> 0.12"

data/spec/lib/rdstation/authentication_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::Authentication do
+  let(:token_endpoint) { 'https://api.rd.services/auth/token' }
+  let(:request_headers) { { 'Content-Type' => 'application/json' } }
+
+  let(:token_request_with_valid_code) do
+    {
+      client_id: 'client_id',
+      client_secret: 'client_secret',
+      code: 'valid_code'
+    }
+  end
+
+  let(:token_request_with_invalid_code) do
+    {
+      client_id: 'client_id',
+      client_secret: 'client_secret',
+      code: 'invalid_code'
+    }
+  end
+
+  let(:token_request_with_expired_code) do
+    {
+      client_id: 'client_id',
+      client_secret: 'client_secret',
+      code: 'expired_code'
+    }
+  end
+
+  let(:token_request_with_valid_refresh_token) do
+    {
+      client_id: 'client_id',
+      client_secret: 'client_secret',
+      refresh_token: 'valid_refresh_token'
+    }
+  end
+
+  let(:token_request_with_invalid_refresh_token) do
+    {
+      client_id: 'client_id',
+      client_secret: 'client_secret',
+      refresh_token: 'invalid_refresh_token'
+    }
+  end
+
+  let(:credentials) do
+    {
+      'access_token' => '123456',
+      'expires_in' => 86_400,
+      'refresh_token' => 'refreshtoken'
+    }
+  end
+
+  let(:credentials_response) do
+    {
+      status: 200,
+      headers: { 'Content-Type' => 'application/json' },
+      body: credentials.to_json
+    }
+  end
+
+  let(:invalid_code_response) do
+    {
+      status: 401,
+      headers: { 'Content-Type' => 'application/json' },
+      body: {
+        errors: {
+          error_type: 'ACCESS_DENIED',
+          error_message: 'Wrong credentials provided.'
+        }
+      }.to_json
+    }
+  end
+
+  let(:expired_code_response) do
+    {
+      status: 401,
+      headers: { 'Content-Type' => 'application/json' },
+      body: {
+        errors: {
+          error_type: 'EXPIRED_CODE_GRANT',
+          error_message: 'The authorization code grant has expired.'
+        }
+      }.to_json
+    }
+  end
+
+  let(:authentication) { described_class.new('client_id', 'client_secret') }
+
+  describe '#authenticate' do
+    context 'when the code is valid' do
+      before do
+        stub_request(:post, token_endpoint)
+          .with(
+            headers: request_headers,
+            body: token_request_with_valid_code.to_json
+          )
+          .to_return(credentials_response)
+      end
+
+      it 'returns the credentials' do
+        credentials_request = authentication.authenticate('valid_code')
+        expect(credentials_request).to eq(credentials)
+      end
+    end
+
+    context 'when the code is invalid' do
+      before do
+        stub_request(:post, token_endpoint)
+          .with(
+            headers: request_headers,
+            body: token_request_with_invalid_code.to_json
+          )
+          .to_return(invalid_code_response)
+      end
+
+      it 'returns an auth error' do
+        expect do
+          authentication.authenticate('invalid_code')
+        end.to raise_error(RDStation::Error::InvalidCredentials)
+      end
+    end
+
+    context 'when the code has expired' do
+      before do
+        stub_request(:post, token_endpoint)
+          .with(
+            headers: request_headers,
+            body: token_request_with_expired_code.to_json
+          )
+          .to_return(expired_code_response)
+      end
+
+      it 'returns an expired code error' do
+        expect do
+          authentication.authenticate('expired_code')
+        end.to raise_error(RDStation::Error::ExpiredCodeGrant)
+      end
+    end
+  end
+
+  describe '#update_access_token' do
+    context 'when the refresh token is valid' do
+      before do
+        stub_request(:post, token_endpoint)
+          .with(
+            headers: request_headers,
+            body: token_request_with_valid_refresh_token.to_json
+          )
+          .to_return(credentials_response)
+      end
+
+      it 'returns the credentials' do
+        credentials_request = authentication.update_access_token('valid_refresh_token')
+        expect(credentials_request).to eq(credentials)
+      end
+    end
+
+    context 'when the refresh token is invalid' do
+      before do
+        stub_request(:post, token_endpoint)
+          .with(
+            headers: request_headers,
+            body: token_request_with_invalid_refresh_token.to_json
+          )
+          .to_return(invalid_code_response)
+      end
+
+      it 'returns an auth error' do
+        expect do
+          authentication.update_access_token('invalid_refresh_token')
+        end.to raise_error(RDStation::Error::InvalidCredentials)
+      end
+    end
+  end
+end

data/spec/lib/rdstation/contacts_spec.rb

@@ -0,0 +1,434 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::Contacts do
+  let(:valid_uuid) { 'valid_uuid' }
+  let(:invalid_uuid) { 'invalid_uuid' }
+  let(:valid_email) { 'valid@email.com' }
+  let(:invalid_email) { 'invalid@email.com' }
+
+  let(:endpoint_with_valid_uuid) { "https://api.rd.services/platform/contacts/#{valid_uuid}" }
+  let(:endpoint_with_invalid_uuid) { "https://api.rd.services/platform/contacts/#{invalid_uuid}" }
+  let(:endpoint_with_valid_email) { "https://api.rd.services/platform/contacts/email:#{valid_email}" }
+  let(:endpoint_with_invalid_email) { "https://api.rd.services/platform/contacts/email:#{invalid_email}" }
+
+  let(:valid_auth_token) { 'valid_auth_token' }
+  let(:invalid_auth_token) { 'invalid_auth_token' }
+  let(:expired_auth_token) { 'expired_auth_token' }
+
+  let(:contact_with_valid_token) { described_class.new(valid_auth_token) }
+  let(:contact_with_expired_token) { described_class.new(expired_auth_token) }
+  let(:contact_with_invalid_token) { described_class.new(invalid_auth_token) }
+
+  let(:valid_headers) do
+    {
+      'Authorization' => "Bearer #{valid_auth_token}",
+      'Content-Type' => 'application/json'
+    }
+  end
+
+  let(:invalid_token_headers) do
+    {
+      'Authorization' => "Bearer #{invalid_auth_token}",
+      'Content-Type' => 'application/json'
+    }
+  end
+
+  let(:expired_token_headers) do
+    {
+      'Authorization' => "Bearer #{expired_auth_token}",
+      'Content-Type' => 'application/json'
+    }
+  end
+
+  let(:not_found_response) do
+    {
+      status: 404,
+      body: {
+        errors: {
+          error_type: 'RESOURCE_NOT_FOUND',
+          error_message: 'Lead not found.'
+        }
+      }.to_json
+    }
+  end
+
+  let(:invalid_token_response) do
+    {
+      status: 401,
+      body: {
+        errors: {
+          error_type: 'UNAUTHORIZED',
+          error_message: 'Invalid token.'
+        }
+      }.to_json
+    }
+  end
+
+  let(:conflicting_field_response) do
+    {
+      status: 400,
+      body: {
+        errors: {
+          error_type: 'CONFLICTING_FIELD',
+          error_message: 'The payload contains an attribute that was used to identify the resource.'
+        }
+      }.to_json
+    }
+  end
+
+  let(:unrecognized_error) do
+    {
+      status: 400,
+      body: {
+        errors: {
+          error_type: 'unrecognized error',
+          error_message: 'Unexpected error.'
+        }
+      }.to_json
+    }
+  end
+
+  let(:expired_token_response) do
+    {
+      status: 401,
+      headers: { 'WWW-Authenticate' => 'Bearer realm="https://api.rd.services/", error="expired_token", error_description="The access token expired"' },
+      body: {
+        errors: {
+          error_type: 'UNAUTHORIZED',
+          error_message: 'Invalid token.'
+        }
+      }.to_json
+    }
+  end
+
+  describe '#by_uuid' do
+    context 'with a valid auth token' do
+      context 'when the contact exists' do
+        let(:contact) do
+          { 'name' => 'Lead', 'email' => 'valid@email.com' }
+        end
+
+        before do
+          stub_request(:get, endpoint_with_valid_uuid)
+            .with(headers: valid_headers)
+            .to_return(status: 200, body: contact.to_json)
+        end
+
+        it 'returns the contact' do
+          response = contact_with_valid_token.by_uuid('valid_uuid')
+          expect(response).to eq(contact)
+        end
+      end
+
+      context 'when the contact does not exist' do
+        before do
+          stub_request(:get, endpoint_with_invalid_uuid)
+            .with(headers: valid_headers)
+            .to_return(not_found_response)
+        end
+
+        it 'raises a not found error' do
+          expect do
+            contact_with_valid_token.by_uuid(invalid_uuid)
+          end.to raise_error(RDStation::Error::ResourceNotFound)
+        end
+      end
+    end
+
+    context 'with an invalid auth token' do
+      before do
+        stub_request(:get, endpoint_with_valid_uuid)
+          .with(headers: invalid_token_headers)
+          .to_return(invalid_token_response)
+      end
+
+      it 'raises an invalid token error' do
+        expect do
+          contact_with_invalid_token.by_uuid(valid_uuid)
+        end.to raise_error(RDStation::Error::Unauthorized)
+      end
+    end
+
+    context 'with an expired auth token' do
+      before do
+        stub_request(:get, endpoint_with_valid_uuid)
+          .with(headers: expired_token_headers)
+          .to_return(expired_token_response)
+      end
+
+      it 'raises a expired token error' do
+        expect do
+          contact_with_expired_token.by_uuid(valid_uuid)
+        end.to raise_error(RDStation::Error::ExpiredAccessToken)
+      end
+    end
+  end
+
+  describe '#by_email' do
+    context 'with a valid auth token' do
+      context 'when the contact exists' do
+        let(:contact) do
+          { 'name' => 'Lead', 'email' => 'valid@email.com' }
+        end
+
+        before do
+          stub_request(:get, endpoint_with_valid_email)
+            .with(headers: valid_headers)
+            .to_return(status: 200, body: contact.to_json)
+        end
+
+        it 'returns the contact' do
+          response = contact_with_valid_token.by_email(valid_email)
+          expect(response).to eq(contact)
+        end
+      end
+
+      context 'when the contact does not exist' do
+        before do
+          stub_request(:get, endpoint_with_invalid_email)
+            .with(headers: valid_headers)
+            .to_return(not_found_response)
+        end
+
+        it 'raises a not found error' do
+          expect do
+            contact_with_valid_token.by_email(invalid_email)
+          end.to raise_error(RDStation::Error::ResourceNotFound)
+        end
+      end
+    end
+
+    context 'with an invalid auth token' do
+      before do
+        stub_request(:get, endpoint_with_valid_email)
+          .with(headers: invalid_token_headers)
+          .to_return(invalid_token_response)
+      end
+
+      it 'raises an invalid token error' do
+        expect do
+          contact_with_invalid_token.by_email(valid_email)
+        end.to raise_error(RDStation::Error::Unauthorized)
+      end
+    end
+
+    context 'with an expired auth token' do
+      before do
+        stub_request(:get, endpoint_with_valid_email)
+          .with(headers: expired_token_headers)
+          .to_return(expired_token_response)
+      end
+
+      it 'raises a expired token error' do
+        expect do
+          contact_with_expired_token.by_email(valid_email)
+        end.to raise_error(RDStation::Error::ExpiredAccessToken)
+      end
+    end
+  end
+
+  describe '#update' do
+    context 'with a valid auth_token' do
+      let(:valid_auth_token) { 'valid_auth_token' }
+      let(:headers) do
+        {
+          'Authorization' => "Bearer #{valid_auth_token}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      context 'with valid params' do
+        let(:contact) do
+          { 'name' => 'Lead', 'email' => 'valid@email.com' }
+        end
+
+        before do
+          stub_request(:patch, endpoint_with_valid_uuid)
+            .with(headers: headers)
+            .to_return(status: 200, body: contact.to_json)
+        end
+
+        it 'returns the updated contact' do
+          updated_contact = contact_with_valid_token.update('valid_uuid', contact)
+          expect(updated_contact).to eq(contact)
+        end
+      end
+
+      context 'when the contact does not exist' do
+        before do
+          stub_request(:patch, endpoint_with_invalid_uuid)
+            .with(headers: headers)
+            .to_return(not_found_response)
+        end
+
+        it 'raises a not found error' do
+          expect do
+            contact_with_valid_token.update(invalid_uuid, {})
+          end.to raise_error(RDStation::Error::ResourceNotFound)
+        end
+      end
+    end
+
+    context 'with an invalid auth token' do
+      let(:invalid_auth_token) { 'invalid_auth_token' }
+      let(:headers) do
+        {
+          'Authorization' => "Bearer #{invalid_auth_token}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      before do
+        stub_request(:patch, endpoint_with_valid_uuid)
+          .with(headers: headers)
+          .to_return(invalid_token_response)
+      end
+
+      it 'raises an invalid token error' do
+        expect do
+          contact_with_invalid_token.update('valid_uuid', {})
+        end.to raise_error(RDStation::Error::Unauthorized)
+      end
+    end
+
+    context 'with an expired auth token' do
+      let(:expired_auth_token) { 'expired_auth_token' }
+      let(:headers) do
+        {
+          'Authorization' => "Bearer #{expired_auth_token}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      before do
+        stub_request(:patch, endpoint_with_valid_uuid)
+          .with(headers: headers)
+          .to_return(expired_token_response)
+      end
+
+      it 'raises a expired token error' do
+        expect do
+          contact_with_expired_token.update('valid_uuid', {})
+        end.to raise_error(RDStation::Error::ExpiredAccessToken)
+      end
+    end
+  end
+
+  describe '#upsert' do
+    context 'with a valid auth_token' do
+      let(:valid_auth_token) { 'valid_auth_token' }
+
+      let(:headers) do
+        {
+          'Authorization' => "Bearer #{valid_auth_token}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      context 'with valid params' do
+        let(:contact) do
+          { 'name' => 'Lead', 'job_title' => 'Developer' }
+        end
+
+        before do
+          stub_request(:patch, endpoint_with_valid_email)
+            .with(headers: headers)
+            .to_return(status: 200, body: contact.to_json)
+        end
+
+        it 'returns the updated contact' do
+          updated_contact = contact_with_valid_token.upsert('email', 'valid@email.com', contact)
+          expect(updated_contact).to eq(contact)
+        end
+      end
+
+      context 'when the contact does not exist' do
+        before do
+          stub_request(:patch, endpoint_with_invalid_email)
+            .with(headers: headers)
+            .to_return(not_found_response)
+        end
+
+        it 'raises a not found error' do
+          expect do
+            contact_with_valid_token.upsert('email', invalid_email, {})
+          end.to raise_error(RDStation::Error::ResourceNotFound)
+        end
+      end
+
+      context 'when the payload has a conflicting field' do
+        let(:conflicting_payload) { { 'email' => valid_email } }
+
+        before do
+          stub_request(:patch, endpoint_with_valid_email)
+            .with(headers: headers)
+            .to_return(conflicting_field_response)
+        end
+
+        it 'raises a conflicting field error' do
+          expect do
+            contact_with_valid_token.upsert('email', valid_email, conflicting_payload)
+          end.to raise_error(RDStation::Error::ConflictingField)
+        end
+      end
+
+      context 'when an unrecognized error occurs' do
+        before do
+          stub_request(:patch, endpoint_with_valid_email)
+            .with(headers: headers)
+            .to_return(unrecognized_error)
+        end
+
+        it 'raises an default error' do
+          expect do
+            contact_with_valid_token.upsert('email', valid_email, {})
+          end.to raise_error(RDStation::Error::Default)
+        end
+      end
+    end
+
+    context 'with an invalid auth token' do
+      let(:invalid_auth_token) { 'invalid_auth_token' }
+      let(:headers) do
+        {
+          'Authorization' => "Bearer #{invalid_auth_token}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      before do
+        stub_request(:patch, endpoint_with_valid_email)
+          .with(headers: headers)
+          .to_return(invalid_token_response)
+      end
+
+      it 'raises an invalid token error' do
+        expect do
+          contact_with_invalid_token.upsert('email', valid_email, {})
+        end.to raise_error(RDStation::Error::Unauthorized)
+      end
+    end
+
+    context 'with an expired auth token' do
+      let(:expired_auth_token) { 'expired_auth_token' }
+      let(:headers) do
+        {
+          'Authorization' => "Bearer #{expired_auth_token}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      before do
+        stub_request(:patch, endpoint_with_valid_email)
+          .with(headers: headers)
+          .to_return(expired_token_response)
+      end
+
+      it 'raises an expired token error' do
+        expect do
+          contact_with_expired_token.upsert('email', valid_email, {})
+        end.to raise_error(RDStation::Error::ExpiredAccessToken)
+      end
+    end
+  end
+end