Finished first draft of all act_as_chargeable specs

@@ -25,6 +25,16 @@ module ActsAsChargeable
 
     def charge_with_conekta(options)
       charge = conekta_charge(options)
+      save_charge_info(charge, options)
+      charge
+    rescue Conekta::ParameterValidationError, Conekta::ProcessingError,
+           Conekta::Error => e
+      update_columns(var_status: 'failed')
+      { error_message: e.message }
+    end
+
+    def save_charge_info(charge, options)
+      # TODO: update more info
       update_columns(var_status: charge.status, var_id: charge.id,
                      var_service: 'conekta')
       update_conekta_barcode(charge) if options[:conekta_type] == 'oxxo'
@@ -32,11 +42,6 @@ module ActsAsChargeable
         time = Time.zone.now
         update_columns(var_payment_at: time)
       end
-      charge
-    rescue Conekta::ParameterValidationError, Conekta::ProcessingError,
-           Conekta::Error => e
-      update_columns(var_status: 'failed')
-      { error_message: e.message }
     end
 
     def conekta_charge(options)
@@ -157,6 +162,7 @@ module ActsAsChargeable
       return { error_message: 'Not charged yet' } unless var_service
       return { error_message: 'Not charged with oxxo' } unless var_barcode
       charge = find_charge
+      # TODO: Revisar redundancia aquí
       if charge.status == 'paid'
         update_columns(var_status: 'paid',
                        var_payment_at: Time.zone.at(charge.paid_at))
@@ -172,6 +178,8 @@ module ActsAsChargeable
 
     private
 
+    # TODO: Missing var attributes to clean
+    # such as var_paid_amount, var_fee, var_payment_method
     def clean_var_variables
       return { object: code } if update(var_status: nil, var_barcode: nil,
                                         var_barcode_url: nil, var_id: nil,

@@ -22,7 +22,7 @@ module Var
       end
 
       def process_charge(charge_info)
-        # TODO: raise error if object is nil
+        # TODO: update status and time
         object = Var.find_charge charge_info[:id]
         object.update(var_status: charge_info[:status])
       end

@@ -6,14 +6,22 @@ describe ActsAsChargeable do
     Product.delete_all
   end
 
+  let!(:Time) {
+    zone = Time.zone
+    now = zone.now
+    time = class_double(Time)
+    allow(zone).to receive(:now) { now }
+    allow(time).to receive(:zone) { zone }
+  }
+
   context 'as a module' do
     it 'can be implemented in ActiveRecord' do
       expect(Product).to respond_to(:acts_as_chargeable)
     end
   end
 
-  context 'processing charges' do
-    it ': oxxo' do
+  context 'Charges with conekta' do
+    it 'An oxxo charge' do
       product = Product.create
       conekta_object_mock = JSON.parse(
         ConektaChargeCreateObject::OXXO_CREATE_CHARGE_OBJECT,
@@ -21,25 +29,23 @@ describe ActsAsChargeable do
       allow(product).to receive(:conekta_charge).and_return(conekta_object_mock)
       
       Var.create_charge(:conekta, product, {"conekta_type": "oxxo"})
-
       expect(product.var_id).to eq conekta_object_mock.id
       expect(product.var_service).to eq 'conekta'
       expect(product.var_status).to eq 'pending_payment'
       expect(product.var_paid_amount).to eq conekta_object_mock.amount
       expect(product.var_fee).to eq conekta_object_mock.fee
       expect(product.var_payment_method).to eq 'OXXO'
-      expect(product.var_payment_at).to eq(Time.strptime conekta_object_mock.paid_at.to_s, '%s')
     end
 
-    it ': card' do
+    it 'A card charge' do
       product = Product.create
       conekta_object_mock = JSON.parse(
         ConektaChargeCreateObject::CARD_CREATE_CHARGE_OBJECT,
         object_class: OpenStruct)
       allow(product).to receive(:conekta_charge).and_return(conekta_object_mock)
 
-      Var.create_charge(:conekta, product, { conekta_type: 'card' })
-
+      Var.create_charge(:conekta, product, { conekta_type: 'card', card_token: 'token' })
+      product.reload
       expect(product.var_id).to eq conekta_object_mock.id
       expect(product.var_service).to eq 'conekta'
       expect(product.var_status).to eq 'paid'
@@ -52,6 +58,198 @@ describe ActsAsChargeable do
     xit ': spei' do
     end
   end
+
+  context 'instance methods' do
+    it 'returns error message if does not support specified service' do
+      product = instance_double('Product')
+      expect do
+        product.charge_with("paypal", { conekta_type: 'card' })
+      end.to raise_error "#{self.class} doesn't support" \
+                        " charges with #{service}"
+    end
+
+    it 'Chooses proper method to attend specified service payment' do
+      product = instance_double('Product')
+      options = { conekta_type: 'card' }
+      expect do
+        product.charge_with("conekta", options)
+      end.to send("charge_with_#{service}", options)
+    end
+
+    it 'Raises Conekta authentication error' do
+      product = instance_double('Product')
+      expect do
+        charge = product.conekta_charge({})
+      end.to raise_error Conekta::AuthenticationError
+    end
+
+    it 'Raises Conekta parameter validation error' do
+      product = instance_double('Product')
+      allow(product).to receive(:conekta_charge).and_raise(Conekta::ParameterValidationError)
+      expect do
+        charge = product.conekta_charge({})
+      end.to raise_error Conekta::ParameterValidationError
+    end
+
+    it 'Raises Conekta parameter processing error' do
+      product = instance_double('Product')
+      allow(product).to receive(:conekta_charge).and_raise(Conekta::ProcessingError)
+      expect do
+        charge = product.conekta_charge({})
+      end.to raise_error Conekta::ProcessingError
+    end
+
+    it 'Raises Conekta error' do
+      product = instance_double('Product')
+      allow(product).to receive(:conekta_charge).and_raise(Conekta::Error)
+      expect do
+        charge = product.conekta_charge({})
+      end.to raise_error Conekta::Error
+    end
+
+    it 'Returns card token' do
+      product = instance_double('Product')
+      hash = product.conekta_type_of_charge(
+              {conekta_type: 'card', card_token: 'token'})
+      returned_hash = {card: 'token'}
+      expect(hash).to eq returned_hash
+    end
+
+    it 'Returns card token' do
+      product = Product.new
+      hash = product.conekta_type_of_charge({conekta_type: 'oxxo'})
+      returned_hash = { cash: { type: 'oxxo', expires_at: (Time.zone.now + 3.days).strftime('%Y-%m-%d') } }
+      expect(hash).to eq returned_hash
+    end
+
+    it 'Updates conekta barcode' do
+      product = instance_double('Product')
+      conekta_object_mock = JSON.parse(
+        ConektaChargeCreateObject::OXXO_CREATE_CHARGE_OBJECT,
+        object_class: OpenStruct)
+      previous_payment_expiration = product.var_payment_expires_at
+
+      product.update_conekta_barcode conekta_object_mock
+      expect(product.var_barcode).to eq conekta_object_mock.payment_method.barcode
+      expect(product.var_barcode_url).to eq conekta_object_mock.payment_method.barcode_url
+      expect(product.var_payment_expires_at).to_not eq previous_payment_expiration
+    end
+
+    it 'Makes manual charge' do
+      product = instance_double('Product')
+      product.manual_charge
+      previous_time = product.var_payment_at
+
+      expect(product.var_service).to eq 'manual'
+      expect(product.status).to eq 'paid'
+      expect(product.var_payment_at).to_not eq previous_time
+    end
+
+    it 'Makes manual discharge' do
+      product = instance_double('Product')
+      product.manual_charge
+
+      expect(product.var_service).to eq 'manual'
+      expect(product.status).to eq 'pending'
+      expect(product.var_payment_at).to be_nil
+    end
+    
+    it 'Return not charged yet error' do
+      product = Product.create
+      msg = product.find_charge
+      error = { error_message: 'Not charged yet' }
+      expect(msg).to eq error
+    end
+
+    it 'Returns Conekta Object' do
+      product = Product.create
+      conekta_object_mock = JSON.parse(
+        ConektaChargeCreateObject::OXXO_CREATE_CHARGE_OBJECT,
+        object_class: OpenStruct)
+      allow(product).to receive(:find_conekta_charge).and_return conekta_object_mock
+      expect(product.find_conekta_charge).to eq conekta_object_mock
+    end
+
+    it 'Returns true when object is charged' do
+      product = Product.create
+      conekta_object_mock = JSON.parse(
+        ConektaChargeCreateObject::CARD_CREATE_CHARGE_OBJECT,
+        object_class: OpenStruct)
+      allow(product).to receive(:find_charge).and_return(conekta_object_mock)
+
+      expect(product.charged?).to be true
+    end
+
+    it 'Returns false when object has not been charged' do
+      product = Product.create
+      expect(product.charged?).to be false
+    end
+
+    xit 'Test instance support' do
+    end
+
+    xit 'Test sync' do
+    end
+
+    xit 'Test conekta_attributes' do
+    end
+
+    it 'Returns true if object is payed' do
+      product = Product.new
+      product.status = 'paid'
+      expect(product.payed?).to be true
+    end
+
+    it 'Returns true if object is payed' do
+      product = Product.new
+      expect(product.payed?).to be false
+    end
+
+    it 'Returns already paid error when cancelling oxxo payment' do
+      product = Product.new
+      product.status = 'paid'
+      error_msg = { error_message: 'Already paid' }
+
+      expect(product.cancel_oxxo_payment).to eq error_msg
+    end
+
+    it 'Returns object not charged error when cancelling oxxo payment' do
+      product = Product.new
+      error_msg = { error_message: 'Not charged yet' }
+
+      expect(product.cancel_oxxo_payment).to eq error_msg
+    end
+
+    it 'Returns not charged with oxxo error when cancelling oxxo payment' do
+      product = Product.new
+      product.var_service = 'conekta'
+      error_msg = { error_message: 'Not charged with oxxo' }
+      expect(product.cancel_oxxo_payment).to eq error_msg
+    end
+
+    it 'Nils every object attribute' do
+      product = Product.create
+      conekta_object_mock = JSON.parse(
+        ConektaChargeCreateObject::OXXO_CREATE_CHARGE_OBJECT,
+        object_class: OpenStruct)
+      allow(product).to receive(:conekta_charge).and_return(conekta_object_mock)
+
+      Var.create_charge(:conekta, product, {"conekta_type": "oxxo"})
+      product.clean_var_variables
+
+      # TODO: Check unused attribute in migration "var_payment::Datetime"
+      expect(product.var_id).to be_nil
+      expect(product.var_service).to be_nil
+      expect(product.var_status).to be_nil
+      expect(product.var_paid_amount).to be_nil
+      expect(product.var_fee).to be_nil
+      expect(product.var_payment_method).to be_nil
+      expect(product.var_barcode).to be_nil
+      expect(product.var_barcode_url).to be_nil
+      expect(product.var_payment_at).to be_nil
+      expect(product.var_payment_expires_at).to be_nil
+    end
+  end
 end
 
 # Tests for mock on Chargeable class

@@ -12,6 +12,7 @@ describe Var::ConektaOxxoHandler do
       ConektaChargeCreateObject::OXXO_CREATE_CHARGE_OBJECT,
       object_class: OpenStruct)
   	allow(product).to receive(:conekta_charge).and_return(conekta_object_mock)
+
     Var.create_charge(:conekta, product, {"conekta_type": "oxxo"})
 
     Var::ConektaOxxoHandler.analyze(WebHookPostRequest::OXXO_CHARGE_CREATED)