alpha_card 0.3.0 → 0.4.0

data/spec/alpha_card/transactions/auth_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe AlphaCard::Auth do
+  let(:order) { AlphaCard::Order.new(id: '1', description: 'Test') }
+  let(:card_exp) { (Time.now + 31104000).strftime('%m%y') }
+  let(:auth) { AlphaCard::Auth.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+
+  context 'with invalid attributes' do
+    let(:response) { described_class.new(card_expiration_date: '1190', card_number: '1', amount: '1').create(order) }
+
+    it 'response with error' do
+      expect(response.error?).to be_truthy
+      expect(response.message).to eq('Transaction was rejected by gateway')
+    end
+  end
+
+  context 'with valid attributes' do
+    it 'has valid request params' do
+      expected_params = {
+        ccexp: card_exp,
+        ccnumber: '4111111111111111',
+        amount: '5.00',
+        payment: 'creditcard',
+        type: 'auth'
+      }
+
+      expect(auth.attributes_for_request).to eq(expected_params)
+    end
+
+    it 'processed successfully' do
+      response = auth.create(order)
+      expect(response.success?).to be_truthy
+      expect(response.text).to eq('SUCCESS')
+    end
+  end
+
+  context 'with blank attributes' do
+    it 'raises an InvalidObject error' do
+      expect { AlphaCard::Auth.new.create(order) }.to raise_error(AlphaCard::ValidationError)
+      expect { AlphaCard::Auth.new(amount: '1.05').create(order) }.to raise_error(AlphaCard::ValidationError)
+    end
+  end
+end

data/spec/alpha_card/{objects → transactions}/capture_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe AlphaCard::Capture do
-  let(:account) { AlphaCard::Account.new('demo', 'password') }
-
   context 'with invalid attributes' do
     let(:capture) { AlphaCard::Capture.new(transaction_id: 'Some ID', amount: '10.05') }
+    let(:response) { capture.process }
 
     it 'response with error' do
-      expect { capture.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+      expect(response.error?).to be_truthy
+      expect(response.message).to eq('Transaction was rejected by gateway')
     end
   end
 
@@ -15,8 +15,8 @@ describe AlphaCard::Capture do
     let(:capture) { AlphaCard::Capture.new(transaction_id: 'Some ID', amount: '10.05', order_id: '1', shipping_carrier: '2') }
 
     let(:order) { AlphaCard::Order.new(id: '1', description: 'Test') }
-    let(:card_exp) { "#{'%02d' % Time.now.month}/#{Time.now.year.next}" }
-    let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+    let(:card_exp) { (Time.now + 31104000).strftime('%m%y') }
+    let(:auth) { AlphaCard::Auth.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
 
     it 'has valid request params' do
       expected_params = {
@@ -31,21 +31,20 @@ describe AlphaCard::Capture do
     end
 
     it 'processed successfully' do
-      allow_any_instance_of(AlphaCard::Sale).to receive(:type).and_return('auth')
-      success, response = sale.create(order, account)
-      expect(success).to be_truthy
+      response = auth.create(order)
+      expect(response.success?).to be_truthy
       expect(response.transaction_id).not_to be_nil
 
-      success, response = AlphaCard::Capture.new(transaction_id: response.transaction_id, amount: '2.00').create(account)
-      expect(success).to be_truthy
+      response = AlphaCard::Capture.new(transaction_id: response.transaction_id, amount: '2.00').create
+      expect(response.success?).to be_truthy
       expect(response.text).to eq('SUCCESS')
     end
   end
 
   context 'with blank attributes' do
     it 'raises an InvalidObject error' do
-      expect { AlphaCard::Refund.new.create(account) }.to raise_error(AlphaCard::InvalidObjectError)
-      expect { AlphaCard::Refund.new(amount: '1.05').create(account) }.to raise_error(AlphaCard::InvalidObjectError)
+      expect { AlphaCard::Refund.new.process }.to raise_error(AlphaCard::ValidationError)
+      expect { AlphaCard::Refund.new(amount: '1.05').process }.to raise_error(AlphaCard::ValidationError)
     end
   end
 end

data/spec/alpha_card/transactions/credit_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe AlphaCard::Credit do
+  let(:order) { AlphaCard::Order.new(id: '1', description: 'Test') }
+  let(:card_exp) { (Time.now + 31104000).strftime('%m%y') }
+
+  context 'with valid attributes' do
+    let(:credit) { AlphaCard::Credit.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+
+    it 'has valid request params' do
+      expected_params = {
+        ccexp: card_exp,
+        ccnumber: '4111111111111111',
+        amount: '5.00',
+        payment: 'creditcard',
+        orderid: '1',
+        orderdescription: 'Test',
+        type: 'credit',
+      }
+
+      expect(credit.send(:params_for_sale, order)).to eq(expected_params)
+    end
+
+    it 'successfully creates the credit' do
+      response = credit.create(order)
+      expect(response.success?).to be_truthy
+    end
+  end
+
+  context 'with invalid amount' do
+    let(:credit) { AlphaCard::Credit.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '0.00') }
+    let(:response) { credit.process(order) }
+
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Invalid amount')
+    end
+  end
+
+  context 'without attributes' do
+    let(:credit) { AlphaCard::Credit.new }
+
+    it 'raises an InvalidObjectError exception' do
+      expect { credit.create(order) }.to raise_error(AlphaCard::ValidationError)
+    end
+  end
+
+  context 'with invalid account credentials' do
+    let(:credit) { AlphaCard::Credit.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+    let(:response) { credit.process(order, username: 'demo', password: 'Invalid password') }
+
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Authentication Failed')
+    end
+  end
+
+  context 'with blank account credentials' do
+    let(:credit) { AlphaCard::Credit.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+
+    it 'raises an ArgumentError' do
+      expect { credit.process(order, username: nil, password: '') }.to raise_error(ArgumentError) do |e|
+        expect(e.message).to include('You must pass a Hash with Account credentials!')
+      end
+    end
+  end
+
+  context 'with connection errors' do
+    let(:timeout_error) { Timeout::Error.new }
+    let(:socket_error) { SocketError.new }
+    let(:unclassified_error) { StandardError.new('Some error') }
+
+    it 'raises an APIConnectionError if Timeout Error' do
+      expect { AlphaCard.handle_connection_errors(timeout_error) }.to raise_error(AlphaCard::APIConnectionError) do |e|
+        expect(e.message).to include('Could not connect to Alpha Card Gateway')
+      end
+    end
+
+    it 'raises an APIConnectionError if Socket Error' do
+      expect { AlphaCard.handle_connection_errors(socket_error) }.to raise_error(AlphaCard::APIConnectionError) do |e|
+        expect(e.message).to include('Unexpected error communicating when trying to connect to Alpha Card Gateway')
+      end
+    end
+
+    it 'raises an APIConnectionError if Unclassified Error' do
+      expect { AlphaCard.handle_connection_errors(unclassified_error) }.to raise_error(AlphaCard::APIConnectionError) do |e|
+        expect(e.message).to include('Unexpected error communicating with Alpha Card Gateway')
+      end
+    end
+
+    context 'with request exception' do
+      let(:credit) { AlphaCard::Credit.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+
+      it 'handles an error' do
+        AlphaCard.api_base = 'https://not-existing.com'
+        expect { credit.create(order) }.to raise_error(AlphaCard::APIConnectionError)
+
+        AlphaCard.api_base = 'https://secure.alphacardgateway.com/api/transact.php'
+      end
+    end
+  end
+end

data/spec/alpha_card/{objects → transactions}/refund_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe AlphaCard::Refund do
-  let(:account) { AlphaCard::Account.new('demo', 'password') }
-
   context 'with invalid attributes' do
     let(:refund) { AlphaCard::Refund.new(transaction_id: 'Some ID', amount: '10.05') }
+    let(:response) { refund.process }
 
     it 'response with error' do
-      expect { refund.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+      expect(response.error?).to be_truthy
+      expect(response.message).to eq('Transaction was rejected by gateway')
     end
   end
 
@@ -29,7 +29,7 @@ describe AlphaCard::Refund do
     let(:refund) { AlphaCard::Refund.new }
 
     it 'raises an InvalidObject error' do
-      expect { refund.create(account) }.to raise_error(AlphaCard::InvalidObjectError)
+      expect { refund.process }.to raise_error(AlphaCard::ValidationError)
     end
   end
 end

data/spec/alpha_card/{objects → transactions}/sale_spec.rb

@@ -1,19 +1,17 @@
 require 'spec_helper'
 
 describe AlphaCard::Sale do
-  # Shared objects
-  let(:account) { AlphaCard::Account.new('demo', 'password') }
-  let(:billing) { AlphaCard::Billing.new(email: 'test@example.com', address_1: 'N', address_2: 'Y') }
-  let(:shipping) { AlphaCard::Shipping.new(first_name: 'John', last_name: 'Doe', address_1: '22 N str.') }
+  let(:billing) { AlphaCard::Billing.new(email: 'test@example.com', address_1: 'N', address_2: 'Y', state: 'MN') }
+  let(:shipping) { AlphaCard::Shipping.new(first_name: 'John', last_name: 'Doe', address_1: '22 N str.', state: 'MN') }
   let(:order) { AlphaCard::Order.new(id: '1', description: 'Test', billing: billing, shipping: shipping) }
-  let(:card_exp) { "#{'%02d' % Time.now.month}/#{Time.now.year.next}" }
+  let(:card_exp) { (Time.now + 31104000).strftime('%m%y') }
 
   context 'with valid attributes' do
     let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
 
     it 'has valid request params' do
       expected_params = {
-        ccexp: '09/2017',
+        ccexp: card_exp,
         ccnumber: '4111111111111111',
         amount: '5.00',
         payment: 'creditcard',
@@ -21,87 +19,90 @@ describe AlphaCard::Sale do
         email: 'test@example.com',
         address1: 'N',
         address2: 'Y',
+        state: 'MN',
         orderid: '1',
         orderdescription: 'Test',
         shipping_address_1: '22 N str.',
         shipping_first_name: 'John',
-        shipping_last_name: 'Doe'
+        shipping_last_name: 'Doe',
+        shipping_state: 'MN'
       }
 
       expect(sale.send(:params_for_sale, order)).to eq(expected_params)
     end
 
     it 'successfully creates the sale' do
-      expect(sale.create(order, account)).to be_truthy
+      expect(sale.create(order)).to be_truthy
     end
   end
 
   context 'with invalid Card number' do
     let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: 'Invalid', amount: '5.00') }
+    let(:response) { sale.process(order) }
 
-    it 'raises an AlphaCardError' do
-      expect { sale.create(order, account) }.to raise_error(AlphaCard::AlphaCardError) do |e|
-        expect(e.message).to include('Card number must contain only digits')
-      end
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Card number must contain only digits')
     end
   end
 
   context 'with invalid amount' do
     let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '0.00') }
+    let(:response) { sale.process(order) }
 
-    it 'raises an AlphaCardError' do
-      expect { sale.create(order, account) }.to raise_error(AlphaCard::AlphaCardError) do |e|
-        expect(e.message).to include('Invalid amount')
-      end
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Invalid amount')
     end
   end
 
   context 'with invalid Card expiration date' do
-    let(:sale) { AlphaCard::Sale.new(card_expiration_date: 'Invalid', card_number: '4111111111111111', amount: '5.00') }
+    let(:sale) { AlphaCard::Sale.new(card_expiration_date: '1299', card_number: '4111111111111111', amount: '5.00') }
 
-    it 'raises an AlphaCardError' do
-      expect { sale.create(order, account) }.to raise_error(AlphaCard::AlphaCardError) do |e|
-        expect(e.message).to include('Card expiration should be in the format')
-      end
+    it 'returns an error' do
+      # Override expiration date without writer (to ignore validation)
+      sale.instance_variable_set(:'@card_expiration_date', '9999')
+      response = sale.process(order)
+
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Card expiration should be in the format')
     end
   end
 
   context 'with invalid Card CVV' do
     let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, cvv: 'Invalid', card_number: '4111111111111111', amount: '5.00') }
+    let(:response) { sale.process(order) }
 
-    it 'raises an AlphaCardError' do
-      expect { sale.create(order, account) }.to raise_error(AlphaCard::AlphaCardError) do |e|
-        expect(e.message).to include('CVV must be')
-      end
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('CVV must be')
     end
   end
 
-  context 'with invalid account credentials' do
-    let(:invalid_account) { AlphaCard::Account.new('demo', 'Invalid password') }
-    let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+  context 'without attributes' do
+    let(:sale) { AlphaCard::Sale.new }
 
-    it 'raises an AlphaCardError' do
-      expect { sale.create(order, invalid_account) }.to raise_error(AlphaCard::AlphaCardError) do |e|
-        expect(e.message).to include('Authentication Failed')
-      end
+    it 'raises an InvalidObjectError exception' do
+      expect { sale.create(order) }.to raise_error(AlphaCard::ValidationError, "card_expiration_date can't be blank")
     end
   end
 
-  context 'without attributes' do
-    let(:sale) { AlphaCard::Sale.new }
+  context 'with invalid account credentials' do
+    let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
+    let(:response) { sale.create(order, username: 'demo', password: 'Invalid password') }
 
-    it 'raises an InvalidObjectError exception' do
-      expect { sale.create(order, account) }.to raise_error(AlphaCard::InvalidObjectError)
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Authentication Failed')
     end
   end
 
   context 'with blank account credentials' do
-    let(:blank_account) { AlphaCard::Account.new(nil, '') }
     let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '5.00') }
 
-    it 'raises an AlphaCardError' do
-      expect { sale.create(order, blank_account) }.to raise_error(AlphaCard::AlphaCardError) do |e|
-        expect(e.message).to include('You must set credentials to create the sale')
+    it 'raises an ArgumentError' do
+      expect { sale.process(order, username: nil, password: '') }.to raise_error(ArgumentError) do |e|
+        expect(e.message).to include('You must pass a Hash with Account credentials!')
       end
     end
   end
@@ -134,7 +135,7 @@ describe AlphaCard::Sale do
 
       it 'handles an error' do
         AlphaCard.api_base = 'https://not-existing.com'
-        expect { sale.create(order, account) }.to raise_error(AlphaCard::APIConnectionError)
+        expect { sale.create(order) }.to raise_error(AlphaCard::APIConnectionError)
 
         AlphaCard.api_base = 'https://secure.alphacardgateway.com/api/transact.php'
       end

data/spec/alpha_card/{objects → transactions}/update_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe AlphaCard::Update do
-  let(:account) { AlphaCard::Account.new('demo', 'password') }
-
   context 'with invalid attributes' do
     let(:update) { AlphaCard::Update.new(transaction_id: 'Some ID') }
+    let(:response) { update.process }
 
     it 'response with error' do
-      expect { update.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+      expect(response.error?).to be_truthy
+      expect(response.message).to eq('Transaction was rejected by gateway')
     end
   end
 
@@ -30,7 +30,7 @@ describe AlphaCard::Update do
     let(:update) { AlphaCard::Update.new }
 
     it 'raises an InvalidObject error' do
-      expect { update.create(account) }.to raise_error(AlphaCard::InvalidObjectError)
+      expect { update.create }.to raise_error(AlphaCard::ValidationError)
     end
   end
 end

data/spec/alpha_card/transactions/validate_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe AlphaCard::Validate do
+  let(:order) { AlphaCard::Order.new(id: '1', description: 'Test') }
+  let(:card_exp) { (Time.now + 31104000).strftime('%m%y') }
+
+  context 'with valid attributes' do
+    let(:validate) { AlphaCard::Validate.new(card_expiration_date: card_exp, card_number: '4111111111111111') }
+
+    it 'has valid request params' do
+      expected_params = {
+        ccexp: card_exp,
+        ccnumber: '4111111111111111',
+        payment: 'creditcard',
+        orderid: '1',
+        orderdescription: 'Test',
+        type: 'validate',
+      }
+
+      expect(validate.send(:params_for_sale, order)).to eq(expected_params)
+    end
+
+    it 'successfully processed' do
+      response = validate.create(order)
+      expect(response.success?).to be_truthy
+    end
+  end
+
+  context 'with amount' do
+    let(:validate) { described_class.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '1.22') }
+
+    it 'must ignore it' do
+      expect(validate.send(:params_for_sale, order)).not_to include(:amount)
+    end
+  end
+
+
+  context 'without attributes' do
+    let(:validate) { described_class.new }
+
+    it 'raises an InvalidObjectError exception' do
+      expect { validate.create(order) }.to raise_error(AlphaCard::ValidationError)
+    end
+  end
+
+  context 'with invalid account credentials' do
+    let(:validate) { described_class.new(card_expiration_date: card_exp, card_number: '4111111111111111') }
+    let(:response) { validate.process(order, username: 'demo', password: 'Invalid password') }
+
+    it 'returns an error' do
+      expect(response.error?).to be_truthy
+      expect(response.text).to include('Authentication Failed')
+    end
+  end
+
+  context 'with blank account credentials' do
+    let(:validate) { described_class.new(card_expiration_date: card_exp, card_number: '4111111111111111') }
+
+    it 'raises an ArgumentError' do
+      expect { validate.process(order, username: nil, password: '') }.to raise_error(ArgumentError) do |e|
+        expect(e.message).to include('You must pass a Hash with Account credentials!')
+      end
+    end
+  end
+
+  context 'with connection errors' do
+    let(:timeout_error) { Timeout::Error.new }
+    let(:socket_error) { SocketError.new }
+    let(:unclassified_error) { StandardError.new('Some error') }
+
+    it 'raises an APIConnectionError if Timeout Error' do
+      expect { AlphaCard.handle_connection_errors(timeout_error) }.to raise_error(AlphaCard::APIConnectionError) do |e|
+        expect(e.message).to include('Could not connect to Alpha Card Gateway')
+      end
+    end
+
+    it 'raises an APIConnectionError if Socket Error' do
+      expect { AlphaCard.handle_connection_errors(socket_error) }.to raise_error(AlphaCard::APIConnectionError) do |e|
+        expect(e.message).to include('Unexpected error communicating when trying to connect to Alpha Card Gateway')
+      end
+    end
+
+    it 'raises an APIConnectionError if Unclassified Error' do
+      expect { AlphaCard.handle_connection_errors(unclassified_error) }.to raise_error(AlphaCard::APIConnectionError) do |e|
+        expect(e.message).to include('Unexpected error communicating with Alpha Card Gateway')
+      end
+    end
+
+    context 'with request exception' do
+      let(:validate) { described_class.new(card_expiration_date: card_exp, card_number: '4111111111111111') }
+
+      it 'handles an error' do
+        AlphaCard.api_base = 'https://not-existing.com'
+        expect { validate.create(order) }.to raise_error(AlphaCard::APIConnectionError)
+
+        AlphaCard.api_base = 'https://secure.alphacardgateway.com/api/transact.php'
+      end
+    end
+  end
+end