conekta 2.5.0 → 6.0.0

data/lib/conekta/util.rb

@@ -1,137 +0,0 @@
-module Conekta
-  module Util
-
-    def self.types
-      @types ||= {
-        'customer_info' => ::Conekta::CustomerInfo,
-        'details' => ::Conekta::Details,
-        'bank_transfer_payment' => ::Conekta::PaymentMethod,
-        'bank_transfer_payout_method' => ::Conekta::Method,
-        'card' => ::Conekta::Card,
-        'card_payment' => ::Conekta::PaymentMethod,
-        'cash_payment' => ::Conekta::PaymentMethod,
-        'charge' => ::Conekta::Charge,
-        'checkout' => ::Conekta::Checkout,
-        'customer' => ::Conekta::Customer,
-        'event' => ::Conekta::Event,
-        'log' => ::Conekta::Log,
-        'payee' => ::Conekta::Payee,
-        'payout' => ::Conekta::Payout,
-        'payout_method' => ::Conekta::PayoutMethod,
-        'destination' => ::Conekta::Destination,
-        'plan' => ::Conekta::Plan,
-        'subscription' => ::Conekta::Subscription,
-        'token' => ::Conekta::Token,
-        'webhook' => ::Conekta::Webhook,
-        'webhook_log' => ::Conekta::WebhookLog,
-        'refund' => ::Conekta::Refund,
-        'line_item' => ::Conekta::LineItem,
-        'address' => ::Conekta::Address,
-        'billing_address' => ::Conekta::Address,
-        'shipping_address' => ::Conekta::Address,
-        'order' => ::Conekta::Order,
-        'payment_source' => ::Conekta::PaymentSource,
-        'tax_line' => ::Conekta::TaxLine,
-        'shipping_line' => ::Conekta::ShippingLine,
-        'discount_line' => ::Conekta::DiscountLine,
-        'shipping_contact' => ::Conekta::ShippingContact,
-        'transfer' => ::Conekta::Transfer,
-        'list' => ::Conekta::List
-      }
-    end
-
-    def self.convert_to_conekta_object(name,resp)
-      # these json strings should not be parsed into objects
-      return resp if ["data", "request_body", "request_headers", "response_headers", "response_body", "query_string", "metadata", "antifraud_info"].include?(name)
-      if resp.kind_of?(Hash)
-        if resp.has_key?('object') and types[resp['object']]
-          if resp['object'] == "list"
-            instance = types[resp['object']].new(name, resp)
-          else
-            instance = types[resp['object']].new()
-          end
-
-          instance.load_from(resp)
-
-          return instance
-        elsif name.instance_of? String
-          name = "shippin_line_method" if name == "method"
-          name = "event_data" if camelize(name) == "Data"
-          name = "obj" if camelize(name) == "Object"
-          if !Object.const_defined?(camelize(name))
-            instance = Object.const_set(camelize(name), Class.new(ConektaObject)).new
-          else
-            begin
-              instance = constantize("Conekta::"+camelize(name)).new
-            rescue # Class is not defined
-              instance = constantize(camelize(name)).new
-            end
-          end
-
-          instance.load_from(resp)
-
-          return instance
-        end
-      end
-
-      if resp.kind_of?(Array)
-        instance = ConektaObject.new
-        instance.load_from(resp)
-        if !resp.empty? and resp.first.instance_of? Hash and !resp.first["object"]
-          resp.each_with_index do |r, i|
-            obj = convert_to_conekta_object(name,r)
-            instance.set_val(i,obj)
-            instance[i] = obj
-          end
-        end
-        return instance
-      end
-      return instance
-    end
-
-    def self.underscore(str)
-      str.split(/::/).last.
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-    end
-
-    protected
-
-    def self.camelize(str)
-      str.split('_').map{|e| e.capitalize}.join
-    end
-
-    def self.constantize(camel_cased_word)
-      names = camel_cased_word.split('::')
-
-      # Trigger a builtin NameError exception including the ill-formed constant in the message.
-      Object.const_get(camel_cased_word) if names.empty?
-
-      # Remove the first blank element in case of '::ClassName' notation.
-      names.shift if names.size > 1 && names.first.empty?
-
-      names.inject(Object) do |constant, name|
-        if constant == Object
-          constant.const_get(name)
-        else
-          candidate = constant.const_get(name)
-          next candidate if constant.const_defined?(name, false)
-          next candidate unless Object.const_defined?(name)
-
-          # Go down the ancestors to check it it's owned
-          # directly before we reach Object or the end of ancestors.
-          constant = constant.ancestors.inject do |const, ancestor|
-            break const    if ancestor == Object
-            break ancestor if ancestor.const_defined?(name, false)
-            const
-          end
-
-          # owner is in Object, so raise
-          constant.const_get(name, false)
-        end
-      end
-    end
-  end
-end

data/lib/conekta/webhook.rb

@@ -1,12 +0,0 @@
-module Conekta
-  class Webhook < Resource
-    include Conekta::Operations::Find
-    include Conekta::Operations::Where
-    include Conekta::Operations::Create
-    include Conekta::Operations::Delete
-    include Conekta::Operations::Update
-    include Conekta::Operations::CustomAction
-
-    attr_accessor :url, :status, :production_enabled, :development_enabled, :subscribed_events
-  end
-end

data/lib/conekta/webhook_log.rb

@@ -1,4 +0,0 @@
-module Conekta
-  class WebhookLog < Resource
-  end
-end

data/locales/en.yml

@@ -1,9 +0,0 @@
-# encoding: UTF-8
-en:
-  error:
-    resource: 
-        id: 'Could not get the id of %{resource} instance.'
-        id_purchaser : 'There was an error. Please contact system administrator.'
-    requestor:
-        connection: 'Could not connect to %{base}.'
-        connection_purchaser: 'Could not connect to payment system.'

data/locales/es.yml

@@ -1,10 +0,0 @@
-# encoding: UTF-8
-es:
-  error:
-    resource:
-        id: 'No se pudo obtener el id de la instancia de %{resource}.'
-        id_purchaser: 'Hubo un error. Favor de contactar al administrador del sistema.'
-    requestor:
-        connection: 'No se pudo conectar a %{base}.'
-        connection_purchaser: 'No se pudo conectar al sistema de pagos.'
-

data/spec/conekta/1.0.0/card_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Conekta::Card do
-  include_context "API 1.0.0"
-  let(:customer_data) do
-    {
-      email: "hola@hola.com",
-      name:  "John Constantine",
-      cards: ["tok_test_visa_4242"]
-    }
-  end
-
-  let(:customer) do
-    Conekta::Customer.create(customer_data)
-  end
-
-  let(:card) { customer.cards.first }
-
-  context "deleting cards" do
-    it "successful card delete" do
-      card.delete
-
-      expect(card.deleted).to eq(true)
-    end
-  end
-
-  context "updating cards" do
-    it "successful card update" do
-      card.update(active: false)
-
-      expect(card.active).to eq(false)
-    end
-
-    it "unsuccessful card update" do
-      expect {
-        card.update(token: "tok_test_visa_4241")
-      }.to raise_error(Conekta::ParameterValidationError)
-    end
-  end
-end

data/spec/conekta/1.0.0/charge_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-describe Conekta::Charge do
-  include_context "API 1.0.0"
-
-  let(:payment_method) do
-    {
-      amount: 2000, 
-      currency: 'mxn', 
-      description: 'Some desc',
-      details: {
-        name: "Wolverine",
-        email: "logan.thomas@xmen.org",
-        phone: "403-342-0642",
-        line_items: [{
-          name: "Shades",
-          description: "Imported From Mex.",
-          unit_price: 20000,
-          quantity: 1,
-          sku: "cohb_s1",
-          category: "eyewear"
-        }]
-      }
-    }
-  end
-
-  let(:invalid_payment_method) do
-    {
-      amount: 10, 
-      currency: 'mxn', 
-      description: 'Some desc',
-      details: {
-        name: "Wolverine",
-        email: "logan.thomas@xmen.org",
-        phone: "403-342-0642",
-        line_items: [{
-          name: "Shades",
-          description: "Imported From Mex.",
-          unit_price: 20000,
-          quantity: 1,
-          sku: "cohb_s1",
-          category: "eyewear"
-        }]
-      }
-    }
-  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
-    it "test succesful where status 'pending_payment'" do
-      charges = Conekta::Charge.where({status: 'pending_payment'})
-      charges.map{|index, charge|
-        expect(charge.status).to eq("pending_payment")
-      }
-    end
-    it "test succesful where status 'paid'" do
-      charges = Conekta::Charge.where({status: 'paid'})
-      charges.map{|index, charge|
-        expect(charge.status).to eq("paid")
-      }
-    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
-
-  context 'capturing charges' do
-    it 'captures an existing charge' do
-      amount_before_capture = 2000
-      amount_after_capture  = 1000
-      capture = { capture: false }
-       transaction = Conekta::Charge.create(
-        payment_method.merge(card).merge(capture)
-      )
-      expect(transaction.status).to eq('pre_authorized')
-      expect(transaction.amount).to be == amount_before_capture 
-      transaction.capture(1000)
-      expect(transaction.amount).to be == amount_after_capture
-      expect(transaction.status).to eq("paid")
-    end
-  end
-end

data/spec/conekta/1.0.0/customer_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe Conekta::Customer do
-  include_context "API 1.0.0"
-  let(:customer_data) { { :cards => ["tok_test_visa_4242"], email: "test@gmail.com", name: "Mario" } }
-
-  context "creating customers" do
-    it "successful customer create" do
-      customer = Conekta::Customer.create(customer_data)
-      expect(customer).to be_a(Conekta::Customer)
-    end
-
-    it "unsuccessful customer create" do
-      expect { Conekta::Customer.create(
-        :cards => ["tok_test_visa_4241"],
-        :name => "Mario",
-        :email => "test@gmail.com"
-      ) }.to raise_error(
-        Conekta::ParameterValidationError,
-        "The token does not exist."
-      )
-    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"],
-        :name => "Mario",
-        :email => "test@gmail.com"
-      })
-      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,
-            'The 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

data/spec/conekta/1.0.0/error_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Conekta::Error do
-  include_context "API 1.0.0"
-  let(:card) { { cards: ["tok_test_visa_4242"] } }
-
-  it "test no id error" do
-    expect { Conekta::Charge.find(nil) }.to raise_error(
-      Conekta::Error, "Could not get the id of Charge instance."
-    )
-  end
-
-  it "test no connection error" do
-    api_url = Conekta::api_base
-    Conekta::api_base = 'http://localhost:3001'
-
-    expect { Conekta::Customer.create(card) }.to raise_error(
-      Conekta::NoConnectionError, "Could not connect to http://localhost:3001."
-    )
-
-    # cleanup
-    Conekta::api_base = api_url
-  end
-
-  it "test api error" do
-    expect { Conekta::Customer.create({ cards: {0=>"tok_test_visa_4242"} }) }.to \
-      raise_error(Conekta::ParameterValidationError)
-  end
-
-  it "test authentication error" do
-    api_key = Conekta::api_key
-    Conekta::api_key = ""
-    expect { Conekta::Customer.create({ cards: ["tok_test_visa_4242"] }) }.to \
-      raise_error(Conekta::AuthenticationError)
-
-    # cleanup
-    Conekta.api_key = api_key
-  end
-
-  it "test parameter validation error" do
-    expect { Conekta::Plan.create({id: 'gold-plan'}) }.to raise_error(
-      Conekta::ParameterValidationError
-    )
-  end
-
-  it "test processing error" do
-    charge = nil
-    charges = Conekta::Charge.where()
-    charges.each do |(k,v)|
-      if v.status == "pre_authorized"
-        charge = v
-        break
-      end
-    end
-    begin
-      if charge
-        charge.capture
-      end
-    rescue Conekta::Error => e
-      expect(e.class_name).to eq("ProcessingError")
-    end
-  end
-
-  it "test resource not found error" do
-    expect { Conekta::Charge.find(1) }.to raise_error(
-      Conekta::ResourceNotFoundError
-    )
-  end
-end

data/spec/conekta/1.0.0/event_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Conekta::Event do
-  include_context "API 1.0.0"
-  it "test successful where" do
-    events = Conekta::Event.where
-    expect(events.class_name).to eq("ConektaObject")
-    expect(events[0].class_name).to eq("Event")
-    if !events[0].webhook_logs.empty?
-      expect(events[0].webhook_logs.first.class_name).to eq("WebhookLog")
-    end
-  end
-
-  it "test successful find" do
-    events = Conekta::Event.where
-    e = events.first
-
-    event = Conekta::Event.find(e.id)
-
-    expect(event).to be_a(Conekta::Event)
-    expect(event.class_name).to eq("Event")
-    if !events[0].webhook_logs.empty?
-      expect(events[0].webhook_logs.first.class_name).to eq("WebhookLog")
-    end
-  end
-end

data/spec/conekta/1.0.0/log_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Conekta::Log do
-  include_context "API 1.0.0"
-  it "test successful where" do
-    events = Conekta::Log.where
-    expect(events.class_name).to eq("ConektaObject")
-    expect(events[0].class_name).to eq("Log")
-  end
-
-  it "test successful find" do
-    events = Conekta::Log.where
-    e = events.first
-
-    event = Conekta::Log.find(e.id)
-
-    expect(event).to be_a(Conekta::Log)
-    expect(event.class_name).to eq("Log")
-  end
-end