conekta 0.5.2 → 0.5.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTE4YzAyYjRjODYyNDg4ZTFmMDM0YmU4ZGI3ZWJhYmQ3MTBjNjI2ZQ==
+    ZDNkOGU4MDA2NzIwODAzMGI0ZjE1NDY5ZmVjNGI3MDVmZjBiYmZjZQ==
   data.tar.gz: !binary |-
-    ZWQzMzY2NjY1MDg0ZTc1ZjE0MzQ2ZDVjY2I4MzEzY2YxZTFmMzkyMg==
+    Y2FhMjIxMzYxNjM0Y2I4MzI1YjA1ZDk2NjE0OWE4OThlYjc3ZGEzZg==
 SHA512:
   metadata.gz: !binary |-
-    NDk1MjEzZTZmNDkzNTQ4NjgxZjQ4ZDE3ZGExZTYxNzY4NzA1ZjVmN2MzYTQy
-    OGFiMjlhNmY0MTgyOGIzMWU1OWZkY2JmODE0ZmFjZWIwNDU1ZjA0MWEwZWZk
-    MWY2NTEzMjFmZTQzMWUxMjM1MmZlNGJkZjc4YWJkZjJlMTNjNjA=
+    MThjMjQ0OGIyODNmYWUxMzUxZTczNjQ3N2ExYmYxMWYyYzIyMmUwNDUzY2Ux
+    ZmM3NjBjMWVhYjRjNjYzYzYzOGMzNjAyMmNmMzVhZjFkNjE2NWRlMTAzNGFh
+    NTkwZjBhMTcwYmU4MDNkZmY2M2RkN2ZlOTk5ZmIxOTc0MjQyN2I=
   data.tar.gz: !binary |-
-    YTI4ODIxNzYyNzQ2YWJjNWNkYjU5ZWU3NjY3NmYxMDlkNGFmZmE1MTAzZGY4
-    NjcwMWNhY2RlY2M5MDFhNGYzN2NmNTkzYzM2MmYwYzc4YWU3ZmMzZDEzZGQw
-    YmJmNTNlY2EwYWY0NjkyOTQ0ZDkyZmUzMzVmODZiYzI5YjFiZTY=
+    ODc1MTU3ZWViM2RiOWExMjBkZjYxMzIzYmFkNjEzNzRhYWI2ZDM2ZDIzMWNh
+    OWY3ZmViMTYyZDNmMDA4MThlMDM0ZGZkOGYwNmQ3ZDBjM2M1NGZhOGE3NTM4
+    YjM0OTgxZGI4MGEyNDAxNzljNzhmYzJhNzMwYzFkOTg2NWJlMTY=

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG

@@ -51,4 +51,8 @@
 
 === 0.5.2 2015-01-20
 
-* Change rspec dependency to development.
+* Change rspec dependency to development.
+
+== 0.5.3 2015-08-13
+
+* Refactorization.

data/README.md

@@ -1,6 +1,6 @@
 ![alt tag](https://raw.github.com/conekta/conekta-ruby/master/readme_files/cover.png)
 
-# Conekta Ruby v.0.4.6
+# Conekta Ruby v.0.5.2
 
 This is a ruby library that allows interaction with https://api.conekta.io API.
 
@@ -20,11 +20,20 @@ Or install it yourself as:
 
 ## Usage
 ```ruby
+# Set your configuration variables
+
 # This change the Accept-Language Header to the locale specified
 Conekta.locale = :es
-    
+
 Conekta.api_key = '1tv5yJp3xnVZ7eK67m4h'
-    
+
+# Or via an initializer in config/initializers/conekta.rb
+Conekta.config do |c|
+  c.locale = :es
+  c.api_key = '1tv5yJp3xnVZ7eK67m4h'
+  c.api_version = '1.0.0'
+end
+
 begin
   charge = Conekta::Charge.create({
     amount: 51000,
@@ -40,7 +49,7 @@ begin
   rescue Conekta::ProcessingError => e
     puts e.message 
     #la tarjeta no pudo ser procesada
-  rescue Conekta::Error
+  rescue Conekta::Error => e
     puts e.message 
     #un error ocurrió que no sucede en el flujo normal de cobros como por ejemplo un auth_key incorrecto
   end

data/conekta.gemspec

@@ -20,8 +20,10 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "bundler", "~> 1.3"
   spec.add_dependency "rake"
-  spec.add_development_dependency "rspec"
   spec.add_dependency "faraday"
   spec.add_dependency "json"
   spec.add_dependency "sys-uname"
+
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
 end

data/lib/conekta.rb

@@ -38,27 +38,38 @@ module Conekta
   @api_version = '1.0.0'
   @locale = 'es'
 
+  def self.config
+    yield self
+  end
+
   def self.api_base
     @api_base
   end
+
   def self.api_base=(api_base)
     @api_base = api_base
   end
+
   def self.api_version
     @api_version
   end
+
   def self.api_version=(api_version)
     @api_version = api_version
   end
+
   def self.api_key
     @api_key
   end
+
   def self.api_key=(api_key)
     @api_key = api_key
   end
+
   def self.locale
     @locale
   end
+
   def self.locale=(locale)
     @locale = locale
   end

data/lib/conekta/error.rb

@@ -31,40 +31,40 @@ module Conekta
       end
       case code
       when 400
-				raise MalformedRequestError.new(@message, @message_to_purchaser, @type, @code, @params)
-			when 401
-				raise AuthenticationError.new(@message, @message_to_purchaser, @type, @code, @params)
-			when 402
-				raise ProcessingError.new(@message, @message_to_purchaser, @type, @code, @params)
-			when 404
-				raise ResourceNotFoundError.new(@message, @message_to_purchaser, @type, @code, @params)
-			when 422
-				raise ParameterValidationError.new(@message, @message_to_purchaser, @type, @code, @params)
-			when 500
-				raise ApiError.new(@message, @message_to_purchaser, @type, @code, @params)
-			else
-				raise Error.new(@message, @message_to_purchaser, @type, @code, @params)
+        raise MalformedRequestError.new(@message, @message_to_purchaser, @type, @code, @params)
+      when 401
+        raise AuthenticationError.new(@message, @message_to_purchaser, @type, @code, @params)
+      when 402
+        raise ProcessingError.new(@message, @message_to_purchaser, @type, @code, @params)
+      when 404
+        raise ResourceNotFoundError.new(@message, @message_to_purchaser, @type, @code, @params)
+      when 422
+        raise ParameterValidationError.new(@message, @message_to_purchaser, @type, @code, @params)
+      when 500
+        raise ApiError.new(@message, @message_to_purchaser, @type, @code, @params)
+      else
+        raise Error.new(@message, @message_to_purchaser, @type, @code, @params)
       end
     end
   end
-  class ApiError < Error		
-	end
-	
-	class NoConnectionError < Error 
-	end
+  class ApiError < Error    
+  end
+  
+  class NoConnectionError < Error 
+  end
 
-	class AuthenticationError < Error 
-	end
+  class AuthenticationError < Error 
+  end
 
-	class ParameterValidationError < Error 
-	end
+  class ParameterValidationError < Error 
+  end
 
-	class ProcessingError < Error 
-	end
+  class ProcessingError < Error 
+  end
 
-	class ResourceNotFoundError < Error 
-	end
+  class ResourceNotFoundError < Error 
+  end
 
-	class MalformedRequestError < Error 
-	end
-end
+  class MalformedRequestError < Error 
+  end
+end

data/lib/conekta/requestor.rb

@@ -1,53 +1,69 @@
 require 'faraday'
 require 'base64'
+
 module Conekta
   class Requestor
     require 'sys/uname'
     include Sys
+
     attr_reader :api_key
-    def initialize()
+
+    def initialize
       @api_key = Conekta.api_key
     end
+
     def api_url(url='')
       api_base = Conekta.api_base
       api_base + url
     end
+
     def request(meth, url, params=nil)
       url = self.api_url(url)
       meth = meth.downcase
+
       begin
-        conn = Faraday.new(
-         :url => url,
-         :ssl => { :ca_file=> File.dirname(__FILE__) + '/../ssl_data/ca_bundle.crt'}
-         ) do |faraday|
-          faraday.adapter  Faraday.default_adapter
-        end
-        conn.headers['X-Conekta-Client-User-Agent'] = set_headers.to_json
-        conn.headers['User-Agent'] = 'Conekta/v1 RubyBindings/' + Conekta::VERSION
-        conn.headers['Accept'] = "application/vnd.conekta-v#{Conekta.api_version}+json"
-        conn.headers['Accept-Language'] = Conekta.locale.to_s
-        conn.headers['Authorization'] = "Basic #{ Base64.encode64("#{self.api_key}" + ':')}"
-        if params
-          conn.params = params
-        end
-        response = conn.method(meth).call
+        connection = build_connection(url, params)
+        response = connection.method(meth).call
       rescue Exception => e
         Error.error_handler(e, "")
       end
-      if response.status != 200
-        Error.error_handler(JSON.parse(response.body), response.status)
-      end
-      return JSON.parse(response.body)
+
+      return Error.error_handler(JSON.parse(response.body), response.status) if response.status != 200
+      JSON.parse(response.body)
     end
+
     private
-    def set_headers
-      headers = {}
-      headers[:bindings_version] = Conekta::VERSION
-      headers[:lang] = 'ruby'
-      headers[:lang_version] = RUBY_VERSION
-      headers[:publisher] = 'conekta'
-      headers[:uname] = Uname.uname
-      return headers
+
+    def build_connection(url, params = nil)
+      connection = Faraday.new(
+       :url => url,
+       :ssl => { :ca_file=> File.dirname(__FILE__) + '/../ssl_data/ca_bundle.crt'}
+       ) do |faraday|
+        faraday.adapter  Faraday.default_adapter
+      end
+
+      set_headers_for(connection)
+      connection.params = params if params
+      return connection
+    end
+
+    def set_headers_for(connection)
+      connection.headers['X-Conekta-Client-User-Agent'] = conekta_headers.to_json
+      connection.headers['User-Agent'] = 'Conekta/v1 RubyBindings/' + Conekta::VERSION
+      connection.headers['Accept'] = "application/vnd.conekta-v#{Conekta.api_version}+json"
+      connection.headers['Accept-Language'] = Conekta.locale.to_s
+      connection.headers['Authorization'] = "Basic #{ Base64.encode64("#{self.api_key}" + ':')}"
+      return connection
+    end
+
+    def conekta_headers
+      @conekta_headers ||= {
+        bindings_version: Conekta::VERSION,
+        lang: 'ruby',
+        lang_version: RUBY_VERSION,
+        publisher: 'conekta',
+        uname: Uname.uname
+      }
     end
   end
-end
+end

data/lib/conekta/version.rb

@@ -1,3 +1,3 @@
 module Conekta
-  VERSION = '0.5.2'.freeze
+  VERSION = '0.5.3'.freeze
 end

data/spec/conekta/charge_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Conekta::Charge do
+  let(:payment_method) do
+    {
+      amount: 2000, currency: 'mxn', description: 'Some desc'
+    }
+  end
+  let(:invalid_payment_method) do
+    {
+      amount: 10, currency: 'mxn', description: 'Some desc'
+    }
+  end
+  let(:card) { { card: 'tok_test_visa_4242' } }
+
+  context "get" do
+    it "succesfully gets charge" do
+      transaction = Conekta::Charge.create(payment_method.merge(card))
+      expect(transaction.status).to eq("paid")
+      charge = Conekta::Charge.find(transaction.id)
+      expect(charge).to be_a(Conekta::Charge)
+    end
+
+    it "test succesful where" do
+      charges = Conekta::Charge.where
+      charge = charges.first
+      expect(charge).to be_a(Conekta::Charge)
+    end
+  end
+
+  context "creating charges" do
+    it "tests succesful bank payment" do
+      bank = { bank: { 'type' => 'banorte' } }
+      bank_payment = Conekta::Charge.create(payment_method.merge(bank))
+      expect(bank_payment.status).to eq("pending_payment")
+    end
+
+    it "tests succesful card payment" do
+      card_payment = Conekta::Charge.create(payment_method.merge(card))
+      expect(card_payment.status).to eq("paid")
+    end
+
+    it "tests succesful oxxo payment" do
+      oxxo = { cash: { 'type' => 'oxxo' } }
+      cash_payment = Conekta::Charge.create(payment_method.merge(oxxo))
+      expect(cash_payment.status).to eq("pending_payment")
+    end
+
+    it "tests succesful card payment capture" do
+      # pm = @valid_payment_method
+      # card = @valid_visa_card
+      capture = { capture: false }
+       transaction = Conekta::Charge.create(
+        payment_method.merge(card).merge(capture)
+      )
+      expect(transaction.status).to eq("pre_authorized")
+      transaction.capture
+      expect(transaction.status).to eq("paid")
+    end
+
+    it "test unsuccesful create" do
+      expect {
+        Conekta::Charge.create(invalid_payment_method.merge(card))
+      }.to raise_error(
+        Conekta::ParameterValidationError,
+        "The minimum for card payments is 3 pesos. Check that the amount " +
+        "is in cents as explained in the documentation."
+        )
+    end
+  end
+
+  context "refunding charges" do
+    it "test susccesful refund" do
+      transaction = Conekta::Charge.create(payment_method.merge(card))
+      expect(transaction.status).to eq("paid")
+      transaction.refund
+      expect(transaction.status).to eq("refunded")
+    end
+
+    it "test unsusccesful refund" do
+      transaction = Conekta::Charge.create(payment_method.merge(card))
+      expect(transaction.status).to eq("paid")
+
+      expect { transaction.refund(3000) }.to raise_error(
+        Conekta::ProcessingError,
+        "The amount to refund exceeds the charge total."
+      )
+    end
+  end
+end

data/spec/conekta/customer_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Conekta::Customer do
+  let(:customer_data) { { :cards => ["tok_test_visa_4242"] } }
+
+  context "creating customers" do
+    it "successful customer create" do
+      customer = Conekta::Customer.create(customer_data)
+      expect(customer).to be_a(Conekta::Customer)
+    end
+
+    it "successful customer create" do
+      expect { Conekta::Customer.create(
+        :cards => ["tok_test_visa_4241"]
+      ) }.to raise_error(
+        Conekta::ResourceNotFoundError,
+        "Object tok_test_visa_4241 could not be found."
+      )
+    end
+  end
+
+  context "getting customers" do
+    it "successful customer get" do
+      transaction = Conekta::Customer.create(customer_data)
+      customer = Conekta::Customer.find(transaction.id)
+      expect(customer).to be_a(Conekta::Customer)
+    end
+
+    it "successful customer where" do
+      customers = Conekta::Customer.where
+      expect(customers.class.class_name).to eq("ConektaObject")
+      expect(customers.first).to be_a(Conekta::Customer)
+    end
+  end
+
+  context "updating customers" do
+    it "successful customer update" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
+      })
+      customer.update({name: 'Logan', email: 'logan@x-men.org'})
+      expect(customer.name).to eq('Logan')
+    end
+  end
+
+  context "deleting customers" do
+    it "successful customer delete" do
+      customer = Conekta::Customer.create(customer_data)
+      customer.delete
+      expect(customer.deleted).to eq(true)
+    end
+  end
+
+  context "adding cards" do
+    let!(:customer) { Conekta::Customer.create(customer_data) }
+
+    it "add card to customer" do
+      card = customer.create_card(:token => 'tok_test_visa_1881')
+      expect(customer.cards.count).to eq(2)
+      expect(customer.cards.last.last4).to eq('1881')
+    end
+
+    it "test delete card" do
+      card = customer.cards[0].delete
+      expect(card.deleted).to eq(true)
+    end
+
+    it "test update card" do
+      customer.cards[0].update(token: 'tok_test_mastercard_4444', active: false)
+      expect(customer.cards[0].last4).to eq('4444')
+    end
+  end
+
+  context "managing subscriptions" do
+    let!(:customer) { Conekta::Customer.create(customer_data) }
+
+    context "create" do
+      it "test succesful create subscription" do
+        subscription = customer.create_subscription({plan: 'gold-plan'})
+        expect(subscription.class.class_name).to eq('Subscription')
+      end
+
+      it "test unsuccesful create subscription" do
+        expect { customer.create_subscription({plan: 'unexistent-plan'}) }.to \
+          raise_error(
+            Conekta::ResourceNotFoundError,
+            "Object Plan unexistent-plan could not be found."
+          )
+      end
+    end
+
+    context "update" do
+      it "test succesful update subscription" do
+        subscription = customer.create_subscription({plan: 'gold-plan'})
+        plan = find_or_create_plan('gold-plan2')
+
+        subscription.update({plan: plan.id})
+        expect(subscription.plan_id).to eq('gold-plan2')
+      end
+    end
+
+    context "pause/resume" do
+      let!(:subscription) { customer.create_subscription({plan: 'gold-plan'}) }
+
+      it "test succesful pause subscription" do
+        subscription.pause
+        expect(subscription.status).to eq('paused')
+      end
+
+      it "test succesful resume subscription" do
+        subscription.pause
+        expect(subscription.status).to eq('paused')
+        subscription.resume
+        expect(subscription.status).to_not eq('paused')
+      end
+    end
+
+    context "cancel" do
+      it "test succesful cancel subscription" do
+        subscription = customer.create_subscription({plan: 'gold-plan'})
+        subscription.cancel
+        expect(subscription.status).to eq('canceled')
+      end
+    end
+  end
+end
+
+def find_or_create_plan(plan_id)
+  plan = Conekta::Plan.find(plan_id)
+rescue Conekta::Error => e
+  plan = Conekta::Plan.create({
+    id: plan_id,
+    name: "Gold Plan",
+    amount: 10000,
+    currency: "MXN",
+    interval: "month",
+    frequency: 1,
+    trial_period_days: 15,
+    expiry_count: 12
+  })
+  return plan
+end