conekta 0.5.2 → 0.5.3

data/spec/conekta/error_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Conekta::Error do
+  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
+    Conekta::api_key = ""
+    expect { Conekta::Customer.create({ cards: ["tok_test_visa_4242"] }) }.to \
+      raise_error(Conekta::AuthenticationError)
+
+    # cleanup
+    Conekta.api_key = '1tv5yJp3xnVZ7eK67m4h'
+  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/event_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Conekta::Event do
+  it "test succesful 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
+end

data/spec/conekta/payee_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+# require 'conekta'
+
+describe Conekta::Payee do
+
+  describe 'an instance' do
+    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
+
+    it 'creates successfully' do
+      payee = Conekta::Payee.create(payee_attributes)
+      expect(payee).to be_a(Conekta::Payee)
+    end
+
+    describe ':payout_methods' do
+      let!(:payee) { Conekta::Payee.create(payee_attributes) }
+      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
+
+      it 'can create payout methods' do
+        payout_method = payee.create_payout_method(bank_attributes)
+        expect(payout_method).to be_a(Conekta::Method)
+        # I'm sure this should be a Conekta::PayoutMethod,
+        # just not sure why it's reporting back as a Conekta::Method
+      end
+
+      it 'assigns default_payout_method_id to first payout method created' do
+        payout_method = payee.create_payout_method(bank_attributes)
+        # refetch the payee object
+        payee = Conekta::Payee.find(payout_method.payee_id)
+        expect(payee.default_payout_method_id).to eq(payout_method.id)
+      end
+    end
+  end
+end

data/spec/conekta/payout_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Conekta::Payout do
+  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/plan_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Conekta::Plan do
+  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/token_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Conekta::Token do
+end

data/spec/conekta/webhook_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Conekta::Webhook do
+  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" } }
+
+  it "succesfully gets charge" do
+    webhook =  Conekta::Webhook.create(url.merge(events))
+    expect(webhook.webhook_url).to eq(url[:url])
+    webhook = Conekta::Webhook.find(webhook.id)
+    expect(webhook.webhook_url).to eq(url[:url])
+    webhook.update({url: "http://localhost:2000/my_listener"})
+    expect(webhook.webhook_url).to eq("http://localhost:2000/my_listener")
+    webhook.delete
+  end
+end

data/spec/conekta_spec.rb

@@ -1,418 +1,23 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-describe :conekta_tests do
-  Conekta.api_key = '1tv5yJp3xnVZ7eK67m4h'
-  describe :payouts_tests do
-    p "payout tests"
-    before :each do
-      @valid_payment_method = {amount: 2000, currency: 'mxn', description: 'Some desc'}
-      @invalid_payment_method = {amount: 10, currency: 'mxn', description: 'Some desc'}
-      @valid_visa_card = {card: 'tok_test_visa_4242'}
-    end
-    it "succesful get payout" do
-      payee = Conekta::Payee.create(name: "John Doe",
-              email: "j_d@radcorp.com",
-              phone: "555555555",
-              bank: {
-                account_number: '032180000118359719',
-                account_holder: 'J D - Radcorp',
-                description: 'Conekta To JD',
-                statement_description: 'Conekta To JD 111111111',
-                statement_reference: '111111111'
-              },
-              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'
-              })
-      payee.class.class_name.should eq("Payee")
-
-      payee.phone.should eq("555555555")
-      payee.payout_methods.first.account_number.should eq('032180000118359719')
-      payee.payout_methods.first.account_holder.should eq('J D - Radcorp')
-      payee.payout_methods.first.bank.should eq('ixe')
-      payee.default_payout_method_id.should_not eq(nil)
+require 'spec_helper'
 
-      payee.payout_methods.first.description.should eq('Conekta To JD')
-      payee.payout_methods.first.statement_description.should eq('Conekta To JD 111111111')
-      payee.payout_methods.first.statement_reference.should eq('111111111')
+describe Conekta do
+  describe ".config" do
+    it "sets the api key initializer style" do
+      Conekta.config { |c| c.api_key = "abc" }
 
-      payee.billing_address.company_name.should eq('Rad Corp')
-      payee.billing_address.tax_id.should eq('tax121212abc')
-      payee.billing_address.zip.should eq('06100')
+      expect(Conekta.api_key).to eq("abc")
+    end
 
-      payout = Conekta::Payout.create(amount: 5000,
-              currency: "MXN",
-              payee: payee.id)
-      payout.class.class_name.should eq("Payout")
-      payout.amount.should eq(5000)
-      payout.currency.should eq("MXN")
+    it "sets the api version initializer style" do
+      Conekta.config { |c| c.api_version = "1.0" }
 
-      payout.method.account_number.should eq('032180000118359719')
-      payout.method.account_holder.should eq('J D - Radcorp')
-      payout.method.bank.should eq('ixe')
-      payout.transactions.count.should eq(0)
-    end
-  end
-  describe :charge_tests do
-    p "charge tests"
-    before :each do
-      @valid_payment_method = {amount: 2000, currency: 'mxn', description: 'Some desc'}
-      @invalid_payment_method = {amount: 10, currency: 'mxn', description: 'Some desc'}
-      @valid_visa_card = {card: 'tok_test_visa_4242'}
-    end
-    it "succesful get charge" do
-      pm = @valid_payment_method
-      card = @valid_visa_card
-      cpm = Conekta::Charge.create(pm.merge(card))
-      cpm.status.should eq("paid")
-      pm = Conekta::Charge.find(cpm.id)
-      pm.class.class_name.should eq("Charge")
-    end
-    it "test succesful where" do
-      charges = Conekta::Charge.where
-      charges.class.class_name.should eq("ConektaObject")
-      charges[0].class.class_name.should eq("Charge")
-    end
-    it "tests succesful bank pm create" do
-      pm = @valid_payment_method
-      bank = {bank: {'type' => 'banorte'}}
-      bpm = Conekta::Charge.create(pm.merge(bank))
-      bpm.status.should eq("pending_payment")
-    end
-    it "tests succesful card pm create" do
-      pm = @valid_payment_method
-      card = @valid_visa_card
-      cpm = Conekta::Charge.create(pm.merge(card))
-      cpm.status.should eq("paid")
-    end
-    it "tests succesful oxxo pm create" do
-      pm = @valid_payment_method
-      oxxo = {cash: {'type' => 'oxxo'}}
-      bpm = Conekta::Charge.create(pm.merge(oxxo))
-      bpm.status.should eq("pending_payment")
-    end
-    it "test unsuccesful pm create" do
-      pm = @invalid_payment_method
-      card = @valid_visa_card
-      begin
-        cpm = Conekta::Charge.create(pm.merge(card))
-      rescue Conekta::Error => e
-        e.message.should eq("The minimum for card payments is 3 pesos. Check that the amount is in cents as explained in the documentation.")
-      end
-    end
-    it "test susccesful refund" do
-      pm = @valid_payment_method
-      card = @valid_visa_card
-      cpm = Conekta::Charge.create(pm.merge(card))
-      cpm.status.should eq("paid")
-      cpm.refund
-      cpm.status.should eq("refunded")
-    end
-    it "test unsusccesful refund" do
-      pm = @valid_payment_method
-      card = @valid_visa_card
-      cpm = Conekta::Charge.create(pm.merge(card))
-      cpm.status.should eq("paid")
-      begin
-        cpm.refund(3000)
-      rescue Conekta::Error => e
-        e.message.should eq("The order does not exist or the amount to refund is invalid")
-      end
-    end
-    it "tests succesful card pm create" do
-      pm = @valid_payment_method
-      card = @valid_visa_card
-      capture = {capture: false}
-      cpm = Conekta::Charge.create(pm.merge(card).merge(capture))
-      cpm.status.should eq("pre_authorized")
-      cpm.capture
-      cpm.status.should eq("paid")
-    end
-  end
-  describe :customer_tests do
-    p "customer tests"
-    it "successful customer create" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      customer.class.class_name.should eq("Customer")
-    end
-    it "successful customer get" do
-      c = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      customer = Conekta::Customer.find(c.id)
-      customer.class.class_name.should eq("Customer")
-    end
-    it "successful customer where" do
-      customers = Conekta::Customer.where
-      customers.class.class_name.should eq("ConektaObject")
-      customers[0].class.class_name.should eq("Customer")
-    end
-    it "successful customer delete" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      customer.delete
-      customer.deleted.should eq(true)
-    end
-    it "successful customer update" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      customer.update({name: 'Logan', email: 'logan@x-men.org'})
-      customer.name.should eq('Logan')
-    end
-    it "successful customer update" do
-      begin
-        customer = Conekta::Customer.create({
-          :cards => ["tok_test_visa_4241"],
-        })
-      rescue Conekta::Error => e
-        e.message.should eq("Object tok_test_visa_4241 could not be found.")
-      end
-    end
-    it "add card to customer" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      card = customer.create_card(:token => 'tok_test_visa_1881')
-      customer.cards.count.should eq(2)
-      customer.cards.last.last4.should eq('1881')
-    end
-    it "test delete card" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      card = customer.cards[0].delete
-      card.deleted.should eq(true)
-    end
-    it "test update card" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      customer.cards[0].update({token: 'tok_test_mastercard_4444', active: false})
-      customer.cards[0].last4.should eq('4444')
-    end
-    it "test succesful create subscription" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      subscription = customer.create_subscription({plan: 'gold-plan'})
-      subscription.class.class_name.should eq('Subscription')
-    end
-    it "test succesful update subscription" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      subscription = customer.create_subscription({plan: 'gold-plan'})
-      begin
-        plan = Conekta::Plan.find('gold-plan2')
-      rescue Conekta::Error => e
-        plan = Conekta::Plan.create({
-          id: "gold-plan2",
-          name: "Gold Plan",
-          amount: 10000,
-          currency: "MXN",
-          interval: "month",
-          frequency: 1,
-          trial_period_days: 15,
-          expiry_count: 12
-        })
-      end
-      subscription.update({plan: plan.id})
-      subscription.plan_id.should eq('gold-plan2')
+      expect(Conekta.api_version).to eq("1.0")
     end
-    it "test unsuccesful create subscription" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      begin
-        subscription = customer.create_subscription({plan: 'unexistent-plan'})
-      rescue Conekta::Error => e
-        e.message.should eq("Object Plan unexistent-plan could not be found.")
-      end
-    end
-    it "test succesful pause subscription" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      subscription = customer.create_subscription({plan: 'gold-plan'})
-      subscription.pause
-      subscription.status.should eq('paused')
-    end
-    it "test succesful resume subscription" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      subscription = customer.create_subscription({plan: 'gold-plan'})
-      subscription.resume
-      subscription.status.should eq('active')
-    end
-    it "test succesful cancel subscription" do
-      customer = Conekta::Customer.create({
-        :cards => ["tok_test_visa_4242"],
-      })
-      subscription = customer.create_subscription({plan: 'gold-plan'})
-      subscription.cancel
-      subscription.status.should eq('canceled')
-    end
-  end
-  describe :error_tests do
-    p "error tests"
-    it "test no id error" do
-      begin
-        charge = Conekta::Charge.find(nil)
-      rescue Conekta::Error => e
-        e.message.should eq('Could not get the id of Charge instance.')
-      end
-    end
-    it "test no connection error" do
-      api_url = Conekta::api_base
-      Conekta::api_base = 'http://localhost:3001'
-      begin
-        customer = Conekta::Customer.create({cards: ["tok_test_visa_4242"]})
-      rescue Exception => e
-        e.class_name.should eq("NoConnectionError")
-      end
-      Conekta::api_base = api_url
-    end
-    it "test api error" do
-      begin
-        customer = Conekta::Customer.create({cards: {0=>"tok_test_visa_4242"}})
-      rescue Conekta::Error => e
-        e.class_name.should eq("ParameterValidationError")
-      end
-    end
-    it "test authentication error" do
-      Conekta::api_key = ""
-      begin
-        customer = Conekta::Customer.create({cards: ["tok_test_visa_4242"]})
-      rescue Conekta::Error => e
-        e.class_name.should eq("AuthenticationError")
-      end
-      Conekta.api_key = '1tv5yJp3xnVZ7eK67m4h'
-    end
-    it "test parameter validation error" do
-      begin
-        plan = Conekta::Plan.create({id: 'gold-plan'})
-      rescue Conekta::Error => e
-        e.class_name.should eq("ParameterValidationError")
-      end
-    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
-        e.class_name.should eq("ProcessingError")
-      end
-    end
-    it "test resource not found error" do
-      begin
-        charge = Conekta::Charge.find(1)
-      rescue Conekta::Error => e
-        e.class_name.should eq("ResourceNotFoundError")
-      end
-    end
-  end
-  describe :event_tests do
-    p "event tests"
-    it "test succesful where" do
-      events = Conekta::Event.where
-      events.class_name.should eq("ConektaObject")
-      events[0].class_name.should eq("Event")
-      if !events[0].webhook_logs.empty?
-        events[0].webhook_logs.first.class_name.should eq("WebhookLog")
-      end
-    end
-  end
-  describe :token_tests do
-    p "token tests"
-  end
-  describe :plan_tests do
-    p "plan tests"
-    it "test succesful get plan" do
-      plans = Conekta::Plan.where
-      p = plans.first;
-      plan = Conekta::Plan.find(p.id)
-      plan.class_name.should eq("Plan")
-    end
-    it "test succesful where" do
-      plans = Conekta::Plan.where
-      plans.class_name.should eq("ConektaObject")
-      plans.first.class_name.should eq("Plan")
-    end
-    it "test succesful create plan" do
-      plans = Conekta::Plan.where
-      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
-					}
-			)
-      plan.class_name.should eq("Plan")
-    end
-    it "test update plan" do
-      plans = Conekta::Plan.where
-      plan = plans.first
-      plan.update({name: "Silver Plan"})
-      plan.name.should eq("Silver Plan")
-    end
-    it "test delete plan" do
-      plans = Conekta::Plan.where
-      plan = plans.first
-      plan.delete
-      plan.deleted.should eq(true)
-    end
-  end
-  describe :webhook_tests do
-    p "webhook tests"
-    before :each do
-      @events = { 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"] }
-      @url = { url: "http://localhost:3000/my_listener" }
-    end
-    it "succesful get charge" do
-      events = @events
-      url = @url
-      webhook =  Conekta::Webhook.create(url.merge(events))
-      webhook.webhook_url.should eq(url[:url])
-      webhook = Conekta::Webhook.find(webhook.id)
-      webhook.webhook_url.should eq(url[:url])
-      webhook.update({url: "http://localhost:2000/my_listener"})
-      webhook.webhook_url.should eq("http://localhost:2000/my_listener")
-      webhook.delete
+
+    it "sets the api locale initializer style" do
+      Conekta.config { |c| c.locale = "es" }
+
+      expect(Conekta.locale).to eq("es")
     end
   end
 end