sendle-api 0.0.2 → 0.0.11

data/lib/sendle/api/factories/errors.rb

@@ -0,0 +1,26 @@
+module Sendle
+  module Api
+    module Factories
+      class Errors
+
+        def self.new_error(rest_client_error)
+          response = JSON.parse(rest_client_error.response)
+          error_text = response['error_description']
+          messages = response['messages']
+
+          case rest_client_error
+          when RestClient::Unauthorized
+            Sendle::Api::Errors::Unauthorized.new(error_text)
+          when RestClient::PaymentRequired
+            Sendle::Api::Errors::PaymentRequired.new(error_text)
+          when RestClient::UnprocessableEntity
+            Sendle::Api::Errors::UnprocessableEntity.new(messages)
+          when  RestClient::PreconditionFailed
+            Sendle::Api::Errors::PreconditionFailed.new(error_text)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sendle/api/order.rb

@@ -0,0 +1,41 @@
+class Sendle::Api::Order < Sendle::Api::Resource
+  include Sendle::Api::Actions::Create
+  include Sendle::Api::Actions::Show
+  include Sendle::Api::Actions::Destroy
+
+  def url
+    Sendle::Api.base_url + "orders"
+  end
+
+  def validate_create_request!(params)
+    # Checking for required params of parcel
+    required = %w( pickup_date kilogram_weight cubic_metre_volume )
+    validate_presence_of!(required, params)
+
+    # Checking for sender params
+    raise Sendle::Api::Errors::MissingParams.new(['sender']) unless hash_contains?(params, :sender) 
+
+    sender_params = params[:sender]
+    raise Sendle::Api::Errors::MissingParams.new(['sender:contact']) unless hash_contains?(sender_params, :contact) 
+    required = %w( name phone )
+    validate_presence_of!(required, sender_params[:contact])
+
+    raise Sendle::Api::Errors::MissingParams.new(['sender:address']) unless hash_contains?(sender_params, :address) 
+    required = %w( address_line1 suburb postcode state_name )
+    validate_presence_of!(required, sender_params[:address])
+
+    # Checking for receiver params
+    raise Sendle::Api::Errors::MissingParams.new(['receiver']) unless hash_contains?(params, :receiver) 
+
+    receiver_params = params[:receiver]
+    raise Sendle::Api::Errors::MissingParams.new(['receiver:contact']) unless hash_contains?(receiver_params, :contact) 
+    required = %w( name )
+    validate_presence_of!(required, receiver_params[:contact])
+
+    raise Sendle::Api::Errors::MissingParams.new(['receiver:address']) unless hash_contains?(receiver_params, :address) 
+    required = %w( address_line1 suburb postcode state_name )
+    validate_presence_of!(required, receiver_params[:address])
+
+  end
+
+end

data/lib/sendle/api/ping.rb

@@ -1,11 +1,16 @@
-class Sendle::Api::Ping
-  extend Sendle::Api::Actions::Index
+class Sendle::Api::Ping < Sendle::Api::Resource
+  include Sendle::Api::Actions::Index
 
   class << self
     alias_method :execute, :index
   end
 
-  def self.url
+  def url
     Sendle::Api.base_url + "ping"
   end
+
+  def process_index_response(response)
+    Sendle::Api::Responses::Pong.new
+  end
+
 end

data/lib/sendle/api/quote.rb

@@ -0,0 +1,28 @@
+class Sendle::Api::Quote < Sendle::Api::Resource
+  include Sendle::Api::Actions::Index
+
+  class << self
+    alias_method :execute, :index
+  end
+
+  def url
+    Sendle::Api.base_url + "quote"
+  end
+
+  def include_credentials?
+    false
+  end
+
+  def validate_index_request!(params)
+    # Checking for required params
+    required = %w( pickup_suburb pickup_postcode delivery_suburb delivery_postcode kilogram_weight)
+    validate_presence_of!(required, params)
+
+    # Checking for valid plan_name, if passed in
+    if params[:plan_name]
+      plan_name = params[:plan_name]
+      raise Sendle::Api::Errors::InvalidPlan.new(plan_name) unless PLANS.include?(plan_name)
+    end
+  end
+
+end

data/lib/sendle/api/resource.rb

@@ -0,0 +1,64 @@
+class Sendle::Api::Resource
+  include Sendle::Api::Actions::Base
+
+  def url
+    raise "An API Resource must implement the url method."
+  end
+
+  def self.url
+    self.new.url
+  end
+
+  def include_credentials?
+    true
+  end
+
+  #Index action hook methods
+  def validate_index_request!(params)
+  end
+
+  def process_index_response(response)
+    return_json(response)
+  end
+
+  #Create action hook methods
+  def validate_create_request!(params)
+  end
+
+  def process_create_response(response)
+    return_json(response)
+  end
+
+  #Show action hook methods
+  def process_show_response(response)
+    return_json(response)
+  end
+
+  #Destroy action hook methods
+  def process_destroy_response(response)
+    return_json(response)
+  end
+
+  def method_missing(m, *args, &blk)
+    if Sendle::Api::Utils.respond_to?(m)
+      Sendle::Api::Utils.send(m, *args)
+    else
+      super(m, *args, blk)
+    end
+  end
+
+  protected
+
+    def return_json(response)
+      Sendle::Api::Responses::Json.new(response)
+    end
+
+    def validate_presence_of!(required_params, hash)
+      symbolize_strings(required_params).each do |required_param|
+        if (!hash.key?(required_param) || nullish?(hash[required_param]))
+          raise Sendle::Api::Errors::MissingParams.new(required_params)
+        end
+      end
+    end
+
+end

data/lib/sendle/api/responses/json.rb

@@ -0,0 +1,15 @@
+module Sendle
+  module Api
+    module Responses
+      class Json
+        attr_reader :raw, :json
+
+        def initialize(json_string)
+          @raw = json_string
+          @json = JSON.parse(json_string)
+        end
+
+      end
+    end
+  end
+end

data/lib/sendle/api/sugars/create.rb

@@ -0,0 +1,13 @@
+module Sendle
+  module Api
+    module Sugars
+      module Create
+        
+        def create(params = {})
+          self.new.create(params)
+        end
+
+      end
+    end
+  end
+end

data/lib/sendle/api/sugars/destroy.rb

@@ -0,0 +1,13 @@
+module Sendle
+  module Api
+    module Sugars
+      module Destroy
+        
+        def destroy(id)
+          self.new.destroy(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/sendle/api/sugars/index.rb

@@ -0,0 +1,13 @@
+module Sendle
+  module Api
+    module Sugars
+      module Index
+        
+        def index(params = {})
+          self.new.index(params)
+        end
+
+      end
+    end
+  end
+end

data/lib/sendle/api/sugars/show.rb

@@ -0,0 +1,13 @@
+module Sendle
+  module Api
+    module Sugars
+      module Show
+        
+        def show(id)
+          self.new.show(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/sendle/api/utils.rb

@@ -0,0 +1,24 @@
+module Sendle
+  module Api
+    class Utils
+
+      class << self
+
+        def symbolize_strings(array_string)
+          array_string.map { |x| x.to_sym }
+        end
+
+        def nullish?(v)
+          v.nil? || v.to_s.empty?
+        end
+
+        def hash_contains?(hash, key)
+          hash.key?(key) && !hash[key].nil?
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/sendle/api/version.rb

@@ -1,5 +1,5 @@
 module Sendle
   module Api
-    VERSION = "0.0.2"
+    VERSION = "0.0.11"
   end
 end

data/spec/sendle/api/order_spec.rb

@@ -0,0 +1,249 @@
+require "spec_helper"
+
+describe Sendle::Api::Order do
+
+  let(:api_key) { 'fake_key' }
+  let(:sendle_id) { 'fake_id' }
+
+  before do
+    Sendle::Api.api_key = api_key
+    Sendle::Api.sendle_id = sendle_id
+  end
+
+  describe "#create" do
+    let(:params) {
+      {
+        pickup_date: "2016-05-05",
+        description: "Kryptonite",
+        kilogram_weight: 1,
+        cubic_metre_volume: 0.01,
+        customer_reference: "SupBdayPressie",
+        sender: {
+          contact: {
+            name: "Lex Luthor",
+            phone: "0412 345 678"
+          },
+          address: {
+            address_line1: "123 Gotham Ln",
+            suburb: "Sydney",
+            state_name: "NSW",
+            postcode: "2000",
+            country: "Australia"
+          },
+          instructions: "Knock loudly"
+        },
+        receiver: {
+          contact: {
+            name: "Clark Kent",
+            email: "clarkissuper@dailyplanet.xyz"
+          },
+          address: {
+            address_line1: "80 Wentworth Park Road",
+            suburb: "Glebe",
+            state_name: "NSW",
+            postcode: "2037",
+            country: "Australia"
+          },
+          instructions: "Give directly to Clark"
+        }
+      }
+    }
+
+    it_behaves_like "a resource action with credentials"
+
+    describe "parcel param validation" do
+      it "validates presence of required params" do
+        params[:pickup_date] = nil
+        params[:kilogram_weight] = nil
+        params[:cubic_metre_volume] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: pickup_date, kilogram_weight, cubic_metre_volume. Please check your request and try again.")
+      end
+    end
+
+    describe "sender details" do
+      it "validates presence of sender object" do
+        params[:sender] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: sender. Please check your request and try again.")
+      end
+
+      it "validates presence of contact" do
+        params[:sender][:contact] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: sender:contact. Please check your request and try again.")
+      end
+
+      it "validates name and phone of contact" do
+        expect {
+          [:phone, :name].each { |attr|  params[:sender][:contact][attr] = nil }
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: name, phone. Please check your request and try again.")
+      end
+
+      it "validates presence of address" do
+        params[:sender][:address] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: sender:address. Please check your request and try again.")
+      end
+
+      it "validates address_line1, suburb, postcode, state_name of the address" do
+        expect {
+          [:address_line1, :suburb, :postcode, :state_name].each { |attr|  params[:sender][:address][attr] = nil }
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: address_line1, suburb, postcode, state_name. Please check your request and try again.")
+      end
+    end 
+
+    describe "receiver details" do
+      it "validates presence of receiver object" do
+        params[:receiver] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: receiver. Please check your request and try again.")
+      end
+
+      it "validates presence of contact" do
+        params[:receiver][:contact] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: receiver:contact. Please check your request and try again.")
+      end
+
+      it "validates name of receiver" do
+        expect {
+          params[:receiver][:contact][:name] = nil 
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: name. Please check your request and try again.")
+      end
+
+      it "validates presence of address" do
+        params[:receiver][:address] = nil
+
+        expect {
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: receiver:address. Please check your request and try again.")
+      end
+
+      it "validates address_line1, suburb, postcode, state_name of the address" do
+        expect {
+          [:address_line1, :suburb, :postcode, :state_name].each { |attr|  params[:receiver][:address][attr] = nil }
+          Sendle::Api::Order.create(params)
+        }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: address_line1, suburb, postcode, state_name. Please check your request and try again.")
+      end
+    end 
+
+    it "handles 412" do
+      expect(RestClient::Request).to receive(:execute).and_raise(PRECONDITION_FAILED_ERROR)
+
+      expect {
+        Sendle::Api::Order.create(params)
+      }.to raise_error(Sendle::Api::Errors::PreconditionFailed, "The account associated with this API key has not accepted the dangerous goods terms. Please visit your Account Settings in https://www.sendle.com/dashboard/ to view and accept these terms.")
+    end
+
+    it "makes the correct request" do
+      expected_params = {
+        method: :post,
+        url: Sendle::Api::Order.url,
+        headers: {
+          accept: :json, 
+          content_type: :json
+        },
+        payload: params
+      }
+
+      expect(RestClient::Request).to receive(:execute).with(hash_including(expected_params)).and_return(ORDER_CREATED_RESPONSE)
+
+      Sendle::Api::Order.create(params)
+    end
+
+    it "returns the correct response" do
+      allow(RestClient::Request).to receive(:execute).and_return(ORDER_CREATED_RESPONSE)
+
+      response = Sendle::Api::Order.create(params)
+
+      expect(response).to be_a Sendle::Api::Responses::Json
+      expect(response.json).to eq JSON.parse(ORDER_CREATED_RESPONSE)
+    end
+
+  end
+
+  describe "#show" do
+    let(:order_id) { "9dbadcd6-ee57-488e-a175-49e378ad29ff" }
+
+    it "throws an error if id isn't provided" do
+      expect {
+        Sendle::Api::Order.show(nil)
+      }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: id. Please check your request and try again.")
+    end
+
+    it "makes the correct request" do
+      expected_params = {
+        method: :get,
+        url: Sendle::Api::Order.url + "/#{order_id}",
+        headers: {
+          accept: :json, 
+          content_type: :json
+        }
+      }
+
+      expect(RestClient::Request).to receive(:execute).with(hash_including(expected_params)).and_return(ORDER_CREATED_RESPONSE)
+
+      Sendle::Api::Order.show(order_id) 
+    end
+
+    it "returns the correct response" do
+      allow(RestClient::Request).to receive(:execute).and_return(ORDER_GET_RESPONSE)
+
+      response = Sendle::Api::Order.show(order_id)
+
+      expect(response).to be_a Sendle::Api::Responses::Json
+      expect(response.json).to eq JSON.parse(ORDER_GET_RESPONSE)
+    end
+  end
+
+  describe "#destroy" do
+    let(:order_id) { "9dbadcd6-ee57-488e-a175-49e378ad29ff" }
+
+    it "throws an error if id isn't provided" do
+      expect {
+        Sendle::Api::Order.destroy(nil)
+      }.to raise_error(Sendle::Api::Errors::MissingParams, "The following params are required: id. Please check your request and try again.")
+    end
+
+    it "makes the correct request" do
+      expected_params = {
+        method: :delete,
+        url: Sendle::Api::Order.url + "/#{order_id}",
+        headers: {
+          accept: :json, 
+          content_type: :json
+        }
+      }
+
+      expect(RestClient::Request).to receive(:execute).with(hash_including(expected_params)).and_return(ORDER_DELETE_RESPONSE)
+
+      Sendle::Api::Order.destroy(order_id) 
+    end
+
+    it "returns the correct response" do
+      allow(RestClient::Request).to receive(:execute).and_return(ORDER_DELETE_RESPONSE)
+
+      response = Sendle::Api::Order.destroy(order_id)
+
+      expect(response).to be_a Sendle::Api::Responses::Json
+      expect(response.json).to eq JSON.parse(ORDER_DELETE_RESPONSE)
+    end
+  end
+
+end