conekta-tiempometa 2.4.2

data/locales/en.yml

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,20 @@
+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

data/spec/conekta/1.0.0/payout_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Conekta::Payout do
+  include_context "API 1.0.0"
+  let(:payee_attributes) do
+    {
+      name: "John Doe", email: "j_d@radcorp.com", phone: "555555555",
+      billing_address:{
+        company_name: 'Rad Corp',
+        tax_id: 'tax121212abc',
+        street1: 'Guadalupe 73',
+        street2: 'Despacho 32',
+        street3: 'Condesa',
+        city: 'Cuauhtemoc',
+        state: 'DF',
+        country: 'MX',
+        zip: '06100'
+      }
+    }
+  end
+
+  let(:bank_attributes) do
+    {
+      account_number: '032180000118359719',
+      account_holder: 'J D - Radcorp',
+      description: 'Conekta To JD',
+      statement_description: 'Conekta To JD 111111111',
+      statement_reference: '111111111'
+    }
+  end
+
+  describe 'an instance' do
+    before do
+      payee = Conekta::Payee.create(payee_attributes)
+      payout_method = payee.create_payout_method(bank_attributes)
+
+      @payee = Conekta::Payee.find(payee.id)
+    end
+
+    it 'is created successfully' do
+      payout = Conekta::Payout.create(
+        amount: 5000, currency: "MXN", payee: @payee.id
+      )
+      expect(payout).to be_a(Conekta::Payout)
+    end
+
+    it 'can be retrieved by :id' do
+      transaction = Conekta::Payout.create(
+        amount: 5000, currency: "MXN", payee: @payee.id
+      )
+      # refetch payout
+      payout = Conekta::Payout.find(transaction.id)
+      expect(payout).to be_a(Conekta::Payout)
+    end
+
+    it 'has a :method attribute' do
+      expect(@payee.payout_methods.first).to be_a(Conekta::Method)
+    end
+  end
+end

data/spec/conekta/1.0.0/plan_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Conekta::Plan do
+  include_context "API 1.0.0"
+  context "get/where" do
+    it "test succesful get plan" do
+      plans = Conekta::Plan.where
+      p = plans.first;
+      plan = Conekta::Plan.find(p.id)
+      expect(plan).to be_a(Conekta::Plan)
+    end
+
+    it "test succesful where" do
+      plans = Conekta::Plan.where
+      expect(plans.class_name).to eq("ConektaObject")
+      expect(plans.first).to be_a(Conekta::Plan)
+    end
+  end
+
+  context "creating plans" do
+    it "test succesful create plan" do
+      plan = Conekta::Plan.create(
+        id: ((0...8).map { (65 + rand(26)).chr }.join),
+        name: "Gold Plan",
+        amount: 10000,
+        currency: "MXN",
+        interval: "month",
+        frequency: 10,
+        trial_period_days: 15,
+        expiry_count: 12
+      )
+      expect(plan).to be_a(Conekta::Plan)
+    end
+  end
+
+  context "updating plans" do
+    it "test update plan" do
+      plans = Conekta::Plan.where
+      plan = plans.first
+      plan.update({name: "Silver Plan"})
+      expect(plan.name).to eq("Silver Plan")
+    end
+  end
+
+  context "deleting plans" do
+    it "test delete plan" do
+      plans = Conekta::Plan.where
+      plan = plans.first
+      plan.delete
+      expect(plan.deleted).to eq(true)
+    end
+  end
+end

data/spec/conekta/1.0.0/token_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Conekta::Token do
+  include_context "API 1.0.0"
+end

data/spec/conekta/1.0.0/webhook_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Conekta::Webhook do
+  include_context "API 1.0.0"
+  let!(:events) do
+    {
+      events: [
+        "charge.created", "charge.paid", "charge.under_fraud_review",
+        "charge.fraudulent", "charge.refunded", "charge.created", "customer.created",
+        "customer.updated", "customer.deleted", "webhook.created", "webhook.updated",
+        "webhook.deleted", "charge.chargeback.created", "charge.chargeback.updated",
+        "charge.chargeback.under_review", "charge.chargeback.lost", "charge.chargeback.won",
+        "payout.created", "payout.retrying", "payout.paid_out", "payout.failed",
+        "plan.created", "plan.updated", "plan.deleted", "subscription.created",
+        "subscription.paused", "subscription.resumed", "subscription.canceled",
+        "subscription.expired", "subscription.updated", "subscription.paid",
+        "subscription.payment_failed", "payee.created", "payee.updated",
+        "payee.deleted", "payee.payout_method.created",
+        "payee.payout_method.updated", "payee.payout_method.deleted"
+      ]
+    }
+  end
+  let(:url) { { url: "http://localhost:3000/my_listener" } }
+
+  # This spec was commented to avoid webhook creation saturation.
+  # 
+  # it "succesfully gets charge" do
+  #   webhook =  Conekta::Webhook.create(url.merge(events))
+  #   expect(webhook.url).to eq(url[:url])
+  #   webhook = Conekta::Webhook.find(webhook.id)
+  #   expect(webhook.url).to eq(url[:url])
+  #   webhook.update({url: "http://localhost:2000/my_listener"})
+  #   expect(webhook.url).to eq("http://localhost:2000/my_listener")
+  #   webhook.delete
+  # end
+end