conekta 0.3.3 → 0.3.5

data/lib/conekta/version.rb

@@ -1,3 +1,3 @@
 module Conekta
-  VERSION = '0.3.3'
+  VERSION = '0.3.5'
 end

data/lib/ssl_data/ca_bundle.crt

@@ -0,0 +1,66 @@
+#Bundled Digicerts
+DigiCert Assured ID Root CA
+===========================
+-----BEGIN CERTIFICATE-----
+MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSQw
+IgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzEx
+MTEwMDAwMDAwWjBlMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQL
+ExB3d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0Ew
+ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7cJpSIqvTO
+9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYPmDI2dsze3Tyoou9q+yHy
+UmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW
+/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpy
+oeb6pNnVFzF1roV9Iq4/AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whf
+GHdPAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRF
+66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYunpyGd823IDzANBgkq
+hkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRCdWKuh+vy1dneVrOfzM4UKLkNl2Bc
+EkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTffwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38Fn
+SbNd67IJKusm7Xi+fT8r87cmNW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i
+8b5QZ7dsvfPxH2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
+-----END CERTIFICATE-----
+
+DigiCert Global Root CA
+=======================
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBhMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSAw
+HgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBDQTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAw
+MDAwMDBaMGExCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3
+dy5kaWdpY2VydC5jb20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkq
+hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsBCSDMAZOn
+TjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97nh6Vfe63SKMI2tavegw5
+BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt43C/dxC//AH2hdmoRBBYMql1GNXRor5H
+4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7PT19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y
+7vrTC0LUq7dBMtoM1O/4gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQAB
+o2MwYTAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbRTLtm
+8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUwDQYJKoZIhvcNAQEF
+BQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/EsrhMAtudXH/vTBH1jLuG2cenTnmCmr
+EbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIt
+tep3Sp+dWOIrWcBAI+0tKIJFPnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886
+UAb3LujEV0lsYSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
+CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
+-----END CERTIFICATE-----
+
+DigiCert High Assurance EV Root CA
+==================================
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBsMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSsw
+KQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5jZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAw
+MFoXDTMxMTExMDAwMDAwMFowbDELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZ
+MBcGA1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFu
+Y2UgRVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm+9S75S0t
+Mqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTWPNt0OKRKzE0lgvdKpVMS
+OO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEMxChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3
+MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFBIk5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQ
+NAQTXKFx01p8VdteZOE3hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUe
+h10aUAsgEsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMB
+Af8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaAFLE+w2kD+L9HAdSY
+JhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3NecnzyIZgYIVyHbIUf4KmeqvxgydkAQ
+V8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6zeM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFp
+myPInngiK3BD41VHMWEZ71jFhS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkK
+mNEVX58Svnw2Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep+OkuE6N36B9K
+-----END CERTIFICATE-----

data/spec/conekta_spec.rb

@@ -1,841 +1,332 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../test_helper', __FILE__)
-#require 'test/unit'
-#require 'shoulda'
-require 'rspec'
-require 'mocha/setup'
-require 'pp'
-require 'rest-client'
-require 'cgi'
-require 'uri'
-
-class ConektaTest < Test::Unit::TestCase
-  include Mocha
-
-  describe Conekta::Util, "#symbolize_names" do
-    it "symbolize_names should convert names to symbols" do
-      start = {
-        'foo' => 'bar',
-        'array' => [{ 'foo' => 'bar' }],
-        'nested' => {
-          1 => 2,
-          :symbol => 9,
-          'string' => nil
-        }
-      }
-      finish = {
-        :foo => 'bar',
-        :array => [{ :foo => 'bar' }],
-        :nested => {
-          1 => 2,
-          :symbol => 9,
-          :string => nil
-        }
-      }
-
-      symbolized = Conekta::Util.symbolize_names(start)
-      finish.should eq(symbolized)
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+describe :conekta_tests do
+  Conekta.api_key = '1tv5yJp3xnVZ7eK67m4h'
+  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 purchase is 3 MXN pesos for card payments")
+      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 Conekta::ConektaObject, "#new" do
-
-    it "creating a new APIResource should not fetch over the network" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-      @mock.expects(:get).never
-      @mock.expects(:post).never
-      c = Conekta::Charge.new("someid")
-      Conekta.mock_rest_client = nil
-    end
-
-    it "creating a new APIResource from a hash should not fetch over the network" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.expects(:get).never
-      @mock.expects(:post).never
-      c = Conekta::Charge.construct_from({
-        id: "somecharge",
-        amount: 10000,
-        currency: 'MXN',
-        card: {
-          number: '4242424242424242',
-          cvc:'123',
-          exp_month:12,
-          exp_year:19,
-          name:'Sebastian Q.'
-        }
+  describe :customer_tests do
+    p "customer tests"
+    it "successful customer create" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
       })
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "setting an attribute should not cause a network request" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.expects(:get).never
-      @mock.expects(:post).never
-      c = Conekta::Charge.new("test_charge");
-      c = Conekta::Charge.construct_from({
-        id: "somecharge",
-        amount: 10000,
-        card: {
-          number: '4242424242424242',
-          cvc:'123',
-          exp_month:12,
-          exp_year:19,
-          name:'Sebastian Q.'
-        }
+      customer.class.class_name.should eq("Customer")
+    end
+    it "successful customer get" do
+      c = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
       })
-      c.currency = 'MXN'
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "accessing id should not issue a fetch" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.expects(:get).never
-      c = Conekta::Charge.new("test_charge");
-      c.id
-
-      Conekta.mock_rest_client = nil
+      customer = Conekta::Customer.find(c.id)
+      customer.class.class_name.should eq("Customer")
     end
-  end
-
-  describe Conekta, "#api_key" do
-    it "not specifying api credentials should raise an exception" do
-      Conekta.api_key = nil
-      expect{Conekta::Charge.new("test_charge").refresh}.to raise_error(Conekta::AuthenticationError)
-    end
-
-    it "specifying api credentials containing whitespace should raise an exception" do
-      Conekta.api_key = "key "
-      expect{Conekta::Charge.new("test_charge").refresh}.to raise_error(Conekta::AuthenticationError)
-    end
-
-    it "specifying invalid api credentials should raise an exception" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      Conekta.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
-
-      @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-      expect{Conekta::Charge.retrieve("failing_charge")}.to raise_error(Conekta::AuthenticationError)
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "AuthenticationErrors should have an http status, http body, and JSON body" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      Conekta.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
-
-      begin
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Conekta::Charge.retrieve("failing_charge")
-      rescue Conekta::AuthenticationError => e
-        401.should eq(e.http_status)
-        true.should_not eq(e.http_body)
-        true.should_not eq(e.json_body[:message])
-        test_invalid_api_key_error['message'].should eq(e.json_body[:message])
-      end
-
-      Conekta.mock_rest_client = nil
+    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
-  end
-
-  describe Conekta::ConektaObject, "#create" do
-
-    it "when specifying per-object credentials with no global API key set, use the per-object credential when creating" do
-      Conekta.api_key = nil
-
-      Conekta.should_receive(:execute_request){|opts|
-        opts[:headers][:authorization].should eq("Basic c2tfdGVzdF9sb2NhbDo=\n")
-        test_response(test_charge)
-      }
-
-      Conekta::Charge.create({:card => {:number => '4242424242424242'}},
-        'sk_test_local')
-    end
-
-    it "when specifying per-object credentials with global API key set, use the per-object credential when creating" do
-      Conekta.api_key = "global"
-
-      Conekta.should_receive(:execute_request){|opts|
-        opts[:headers][:authorization].should eq("Basic c2tfdGVzdF9sb2NhbDo=\n")
-        test_response(test_charge)
-      }
-
-      Conekta::Charge.create({:card => {:number => '4242424242424242'}},
-        'sk_test_local')
-    end
-
-    it "when specifying per-object credentials with a global API key set, use the per-object credential when retrieving and making other calls" do
-      Conekta.api_key = "global"
-
-      Conekta.should_receive(:execute_request){|opts|
-        opts[:url].should eq("#{Conekta.api_base}/charges/ch_test_charge.json")
-        opts[:headers][:authorization].should eq("Basic c2tfdGVzdF9sb2NhbDo=\n")
-        test_response(test_charge)
-      }
-      Conekta.should_receive(:execute_request){|opts|
-        opts[:url].should eq("#{Conekta.api_base}/charges/ch_test_charge/refund.json")
-        opts[:headers][:authorization].should eq("Basic c2tfdGVzdF9sb2NhbDo=\n")
-        test_response(test_charge)
-      }
-
-      ch = Conekta::Charge.retrieve('ch_test_charge', 'sk_test_local')
-      ch.refund
+    it "successful customer delete" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
+      })
+      customer.delete
+      customer.deleted.should eq(true)
     end
-  end
-
-  describe Conekta, "#execute_request" do
-    it "with valid credential, urlencode values in GET params" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      Conekta.api_key = 'foo'
-      response = test_response(test_charge_array)
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-
-        arg1.should eq("#{Conekta.api_base}/charges.json?amount=500")
-        arg2.should eq(nil)
-        arg3.should eq(nil)
-        response
-      }
-      charges = Conekta::Charge.all(amount: 500).data
-      charges.should be_kind_of(Array)
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "with valid credential, construct URL properly with base query parameters" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_charge_array)
-
-      Conekta.api_key = 'foo'
-      response = test_response(test_charge_array_filtered)
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-        arg1.should eq("#{Conekta.api_base}/charges.json?amount=500")
-        arg2.should eq(nil)
-        arg3.should eq(nil)
-        response
-      }
-      charges = Conekta::Charge.all(amount:  500)
-
-      response = test_response(test_charge_array_filtered)
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-        arg1.should eq("#{Conekta.api_base}/charges.json?amount=500&status=paid")
-        arg2.should eq(nil)
-        arg3.should eq(nil)
-        response
-      }
-      charges.all(:status=>'paid')
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "with valid credential, a 401 should give an AuthenticationError with http status, body, and JSON body" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_missing_id_error, 401)
-      @mock.should_receive(:get){|args|
-        raise RestClient::ExceptionWithResponse.new(response, 401)
-      }.once
-
-      begin
-        Conekta::Charge.retrieve("foo")
-      rescue Conekta::AuthenticationError => e
-        e.http_status.should eq(401)
-        e.http_body.should_not eq(true)
-        e.json_body.should be_kind_of(Hash)
-      end
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "with valid credential, a 402 should give an CardError with http status, body, and JSON body" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_missing_id_error, 402)
-      @mock.should_receive(:post){|args|
-        raise RestClient::ExceptionWithResponse.new(response, 402)
-      }.once
-
+    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
-        Conekta::Charge.create({
-          amount:10000,
-          description:'Test',
-          card: {
-            name:'Leo Fischer',
-            number:4000000000000119,
-            cvc:123,
-            exp_month:8,
-            exp_year:19
-          }
+        customer = Conekta::Customer.create({
+          :cards => ["tok_test_visa_4241"],
         })
-
-      rescue Conekta::CardError => e
-        e.http_status.should eq(402)
-        e.http_body.should_not eq(true)
-        e.json_body.should be_kind_of(Hash)
+      rescue Conekta::Error => e
+        e.message.should eq("Token 'tok_test_visa_4241' could not be found.")
       end
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "with valid credential, a 404 should give an ResourceNotFoundError with http status, body, and JSON body" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_missing_id_error, 404)
-      @mock.should_receive(:get){|args|
-        raise RestClient::ExceptionWithResponse.new(response, 404)
-      }.once
-
+    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
-        Conekta::Charge.retrieve("foo")
-      rescue Conekta::ResourceNotFoundError => e
-        e.http_status.should eq(404)
-        e.http_body.should_not eq(true)
-        e.json_body.should be_kind_of(Hash)
+        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
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "with valid credential, a 422 should give an ParameterValidationError with http status, body, and JSON body" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_missing_id_error, 422)
-      @mock.should_receive(:post){|args|
-        raise RestClient::ExceptionWithResponse.new(response, 422)
-      }.once
-
+      subscription.update({plan: plan.id})
+      subscription.plan_id.should eq('gold-plan2')
+    end
+    it "test unsuccesful create subscription" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
+      })
       begin
-        Conekta::Charge.create({amount:-10000})
-      rescue Conekta::ParameterValidationError => e
-        e.http_status.should eq(422)
-        e.http_body.should_not eq(true)
-        e.json_body.should be_kind_of(Hash)
+        subscription = customer.create_subscription({plan: 'unexistent-plan'})
+      rescue Conekta::Error => e
+        e.message.should eq("Plan 'unexistent-plan' does not exist and cannot be used to create a new subsription.")
       end
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "with valid credential, setting a nil value for a param should exclude that param from the request" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){|url, api_key, params|
-        uri = URI(url)
-        query = CGI.parse(uri.query)
-        url.should match(%r{^#{Conekta.api_base}/charges?})
-        query.keys.sort.should eq(['offset', 'sad'])
-
-        test_response({ :count => 1, :data => [test_charge] })
-      }
-      c = Conekta::Charge.all(:count => nil, :offset => 5, :sad => false)
-
-      @mock.should_receive(:post){|url, api_key, params|
-        "#{Conekta.api_base}/charges.json".should eq(url)
-        api_key.should eq(nil)
-        {:amount => 50, :currency=>'usd', :card=>{}}.should eq(JSON.parse(params).symbolize_keys)
-
-        test_response({ :count => 1, :data => [test_charge] })
-      }
-      c = Conekta::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
-      Conekta.mock_rest_client = nil
-    end
-
-    it "requesting with a unicode ID should result in a request" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_missing_id_error, 400)
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-        arg1.should eq("#{Conekta.api_base}/charges/%E2%98%83.json")
-        arg2.should eq(nil)
-        arg3.should eq(nil)
-        raise RestClient::ExceptionWithResponse.new(response, 400)
-      }.once
-      c = Conekta::Charge.new("☃")
-      expect{c.refresh}.to raise_error(Conekta::MalformedRequestError)
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "requesting with no ID should result in an ParameterValidationError with no request" do
-      c = Conekta::Charge.new
-      expect{c.refresh}.to raise_error(Conekta::ParameterValidationError)
-    end
-
-    it "making a GET request with parameters should have a query string and no body" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      params = { :limit => 1 }
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-        arg1.should eq("#{Conekta.api_base}/charges.json?limit=1")
-        arg2.should eq(nil)
-        arg3.should eq(nil)
-        test_response([test_charge])
-      }.once
-      c = Conekta::Charge.all(params)
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "making a POST request with parameters should have a body and no query string" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      params = { :amount => 100, :currency => 'usd', :card => 'sc_token' }
-      @mock.should_receive(:post){|url, get, post|
-        get.should eq(nil)
-        JSON.parse(post).symbolize_keys.should eq({:amount => 100, :currency => 'usd', :card => 'sc_token'})
-        test_response(test_charge)
-      }
-      c = Conekta::Charge.create(params)
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "loading an object should issue a GET request" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-        test_response(test_charge)
-      }.once
-      c = Conekta::Charge.new("test_charge")
-      c.refresh
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "using array accessors should be the same as the method interface" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){|arg1, arg2, arg3|
-        test_response(test_charge)
-      }.once
-      c = Conekta::Charge.new("test_charge")
-      c.refresh
-      c.created.should eq(c[:created])
-      c.created.should eq(c['created'])
-      c['created'] = 12345
-      c.created.should eq(12345)
-
-      Conekta.mock_rest_client = nil
-    end
-
-#    it "accessing a property other than id or parent on an unfetched object should fetch it" do
-#      @mock = double
-#      Conekta.mock_rest_client = @mock
-#
-#      @mock.should_receive(:get){
-#        test_response(test_charge)
-#      }.once
-#      c = Conekta::Charge.new("test_charge")
-#      c.card
-#
-#      Conekta.mock_rest_client = nil
-#    end
-
-    it "updating an object should issue a POST request with only the changed properties" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:post){|url, api_key, params|
-        url.should eq("#{Conekta.api_base}/charges/ch_test_charge.json")
-        api_key.should eq(nil)
-        JSON.parse(params).symbolize_keys.should eq({:mnemonic => 'another_mn'})
-        test_response(test_charge)
-      }.once
-      c = Conekta::Charge.construct_from(test_charge)
-      c.mnemonic = "another_mn"
-      c.save
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "updating should merge in returned properties" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:post){
-        test_response(test_charge)
-      }.once
-      c = Conekta::Charge.new("c_test_charge")
-      c.mnemonic = "another_mn"
-      c.save
-      c.livemode.should eq(false)
-
-      Conekta.mock_rest_client = nil
-    end
-
-#    it "deleting should send no props and result in an object that has no props other deleted" do
-#      @mock = double
-#      Conekta.mock_rest_client = @mock
-#
-#      @mock.expects(:get).never
-#      @mock.expects(:post).never
-#      @mock.should_receive(:delete){|arg1, arg2, arg3|
-#        arg1.should eq("#{Conekta.api_base}/v1/charges/ch_test_charge")
-#        arg2.should eq(nil)
-#        arg3.should eq(nil)
-#
-#        test_response({ "id" => "test_charge", "deleted" => true })
-#      }.once
-#
-#      c = Conekta::Customer.construct_from(test_charge)
-#      c.delete
-#      c.deleted.should eq(true)
-#
-#      c.livemode.to raise_error(NoMethodError)
-#    end
-
-    it "loading an object with properties that have specific types should instantiate those classes" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){
-        test_response(test_charge)
-      }.once
-
-      c = Conekta::Charge.retrieve("test_charge")
-      c.card.should be_kind_of(Conekta::ConektaObject)
-      #c.card.object == 'card'
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "loading all of an APIResource should return an array of recursively instantiated objects" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){
-        test_response(test_charge_array)
-      }.once
-      c = Conekta::Charge.all
-      c = c.data
-      c.should be_kind_of(Array)
-      c[0].should be_kind_of(Conekta::Charge)
-      c[0].card.should be_kind_of(Conekta::ConektaObject)
-      #c[0].card.object == 'card'
-      
-      Conekta.mock_rest_client = nil
-    end
-  end
-
-  describe Conekta::Account, "#retrieve" do
-    it "account should be retrievable" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      resp = {:email => "test+bindings@conekta.com", :charge_enabled => false, :details_submitted => false}
-      @mock.should_receive(:get){test_response(resp)}.once
-      a = Conekta::Account.retrieve
-      "test+bindings@conekta.com".should eq(a.email)
-      a.charge_enabled.should eq(false)
-      a.details_submitted.should eq(false)
-
-      Conekta.mock_rest_client = nil
-    end
-  end
-
-  describe Conekta::ListObject, "#all" do
-    it "be able to retrieve full lists given a listobject" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){
-        test_response(test_charge_array)
-      }.twice
-
-      c = Conekta::Charge.all
-      c.should be_kind_of(Conekta::ListObject)
-      '/charges'.should eq(c.url)
-      all = c.all
-      all.should be_kind_of(Conekta::ListObject)
-      '/charges'.should eq(all.url)
-      all.data.should be_kind_of(Array)
-
-      Conekta.mock_rest_client = nil
     end
-  end
-
-  describe "customer with token tests" do
-    it "execute should return a new customer" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:post){|url, api_key, params|
-        url.should eq("#{Conekta.api_base}/customers.json") 
-        api_key.should eq(nil) 
-        JSON.parse(params).symbolize_keys.should eq({
-          :cards=>["TOKEN_ID"]
-        })
-
-        test_response(test_customer)
-      }.once
-
-      c = Conekta::Customer.create({
-        :cards => ["TOKEN_ID"],
+    it "test succesful pause subscription" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
       })
-      c.cards.first.last4.should eq("4242")
-
-      Conekta.mock_rest_client = nil
+      subscription = customer.create_subscription({plan: 'gold-plan'})
+      subscription.pause
+      subscription.status.should eq('paused')
     end
-  end
-
-  describe "plan tests" do
-    it "execute should return a new plan" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:post){|url, api_key, params|
-        url.should eq("#{Conekta.api_base}/plans.json") 
-        api_key.should eq(nil) 
-        JSON.parse(params).symbolize_keys.should eq({
-          :id => "gold-plan",
-          :name => "Gold Plan",
-          :amount => 10000,
-          :currency => "MXN",
-          :interval => "month",
-          :frequency => 1,
-          :trial_period_days => 15,
-          :expiry_count => 12
-        })
-
-        test_response(test_plan)
-      }.once
-
-      p = Conekta::Plan.create({
-          :id => "gold-plan",
-          :name => "Gold Plan",
-          :amount => 10000,
-          :currency => "MXN",
-          :interval => "month",
-          :frequency => 1,
-          :trial_period_days => 15,
-          :expiry_count => 12
+    it "test succesful resume subscription" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
       })
-      p.id.should eq("gold-plan")
-
-      Conekta.mock_rest_client = nil
+      subscription = customer.create_subscription({plan: 'gold-plan'})
+      subscription.resume
+      subscription.status.should eq('active')
     end
-  end
-
-  describe "token tests" do
-    it "execute should return a new token" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:post){|url, api_key, params|
-        url.should eq("#{Conekta.api_base}/tokens.json") 
-        api_key.should eq(nil) 
-        params = JSON.parse(params).symbolize_keys 
-        params[:card] = params[:card].symbolize_keys
-        params.should eq({
-          :card => {
-            :number => "4242424242424242",
-            :exp_month => 11,
-            :exp_year => 2012,
-          }
-        })
-
-        test_response(test_token)
-      }.once
-
-      t = Conekta::Token.create({
-        :card => {
-          :number => "4242424242424242",
-          :exp_month => 11,
-          :exp_year => 2012,
-        }
+    it "test succesful cancel subscription" do
+      customer = Conekta::Customer.create({
+        :cards => ["tok_test_visa_4242"],
       })
-      t.used.should eq(false)
-
-      Conekta.mock_rest_client = nil
+      subscription = customer.create_subscription({plan: 'gold-plan'})
+      subscription.cancel
+      subscription.status.should eq('canceled')
     end
   end
-
-
-  describe "charge tests" do
-    it "charges should be listable" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){
-        test_response(test_charge_array)
-      }.once
-      c = Conekta::Charge.all
-      c.data.should be_kind_of(Array)
-      c.each do |charge|
-        charge.should be_kind_of(Conekta::Charge)
+  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
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "charges should be refundable" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.expects(:get).never
-      @mock.should_receive(:post){test_response({:id => "ch_test_charge", :refunded => true})}.once
-      c = Conekta::Charge.new("test_charge")
-      c.refund
-      c.refunded.should eq(true)
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "charges should not be deletable" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){test_response(test_charge)}.once
-      c = Conekta::Charge.retrieve("test_charge")
-      expect{c.delete}.to raise_error(NoMethodError)
-
-      Conekta.mock_rest_client = nil
-    end
-
-
-    it "charges should be updateable" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){test_response(test_charge)}.once
-      @mock.should_receive(:post){test_response(test_charge)}.once
-      c = Conekta::Charge.new("test_charge")
-      c.refresh
-      c.mnemonic = "New charge description"
-      c.save
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "charges should have Card objects associated with their Card property" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:get){test_response(test_charge)}.once
-      c = Conekta::Charge.retrieve("test_charge")
-      c.card.should be_kind_of(Conekta::ConektaObject)
-      #&& c.card.object == 'card'
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "execute should return a new, fully executed charge when passed correct parameters" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      @mock.should_receive(:post){|url, api_key, params|
-        url.should eq("#{Conekta.api_base}/charges.json") 
-        api_key.should eq(nil)
-        params = JSON.parse(params).symbolize_keys 
-        params[:card] = params[:card].symbolize_keys
-        params.should eq({
-          :currency => 'usd', 
-          :amount => 100,
-          :card=>{
-            :number => '4242424242424242',
-            :exp_month => 11,
-            :exp_year => 2012
-          }
-        })
-
-        test_response(test_charge)
-      }.once
-
-      c = Conekta::Charge.create({
-        :amount => 100,
-        :card => {
-          :number => "4242424242424242",
-          :exp_month => 11,
-          :exp_year => 2012,
-        },
-        :currency => "usd"
-      })
-      c.paid.should eq(true)
-
-      Conekta.mock_rest_client = nil
     end
-  end
-
-  describe Conekta::ConektaError do
-    it "404s should raise an ResourceNotFoundError" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_missing_id_error, 404)
-      @mock.should_receive(:get){raise RestClient::ExceptionWithResponse.new(response, 404)}.once
-
+    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("ApiError")
+      end
+    end
+    it "test authentication error" do
+      Conekta::api_key = ""
       begin
-        Conekta::Charge.new("test_charge").refresh
-      rescue Conekta::ResourceNotFoundError => e # we don't use assert_raises because we want to examine e
-        e.should be_kind_of(Conekta::ResourceNotFoundError)
-        "id".should eq(e.param)
-        "Invalid id value".should eq(e.message)
+        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
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "5XXs should raise an APIError" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_api_error, 500)
-      @mock.should_receive(:get){raise RestClient::ExceptionWithResponse.new(response, 500)}.once
-
       begin
-        Conekta::Charge.new("test_charge").refresh
-      rescue Conekta::APIError => e # we don't use assert_raises because we want to examine e
-        e.should be_kind_of(Conekta::APIError)
+        if charge
+          charge.capture
+        end
+      rescue Conekta::Error => e
+        e.class_name.should eq("ProcessingError")
       end
-
-      Conekta.mock_rest_client = nil
-    end
-
-    it "402s should raise a CardError" do
-      @mock = double
-      Conekta.mock_rest_client = @mock
-
-      response = test_response(test_invalid_exp_year_error, 402)
-      @mock.should_receive(:get){raise RestClient::ExceptionWithResponse.new(response, 402)}.once
-
+    end
+    it "test resource not found error" do
       begin
-        Conekta::Charge.new("test_charge").refresh
-      rescue Conekta::CardError => e # we don't use assert_raises because we want to examine e
-        e.should be_kind_of(Conekta::CardError)
-        "invalid_expiry_year".should eq(e.code)
-        "exp_year".should eq(e.param)
-        "Your card's expiration year is invalid".should eq(e.message)
+        charge = Conekta::Charge.find(1)
+      rescue Conekta::Error => e
+        e.class_name.should eq("ResourceNotFoundError")
       end
-
-      Conekta.mock_rest_client = nil
+    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")
+    end
+  end
+  describe :token_tests do
+    p "token tests"
+    it "test succesful where" do
+      token = Conekta::Token.find("tok_test_visa_4242")
+      token.class_name.should eq("Token")
+    end
+  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: "gold-plan#{plans.count}",
+					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
 end