alpha_card 0.2.6 → 0.3.0

data/spec/alpha_card/objects/capture_spec.rb

@@ -0,0 +1,51 @@
+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') }
+
+    it 'response with error' do
+      expect { capture.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+    end
+  end
+
+  context 'with valid attributes' 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') }
+
+    it 'has valid request params' do
+      expected_params = {
+        transactionid: 'Some ID',
+        type: 'capture',
+        amount: '10.05',
+        shipping_carrier: '2',
+        orderid: '1'
+      }
+
+      expect(capture.attributes_for_request).to eq(expected_params)
+    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
+      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
+      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)
+    end
+  end
+end

data/spec/alpha_card/objects/deprecated_methods_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'AlphaCard objects deprecated methods' do
+  def warn_writer(old_method, new_method)
+    "[DEPRECATION] #{old_method}= is deprecated! Please, use #{new_method}= instead\n"
+  end
+
+  def warn_reader(old_method, new_method)
+    "[DEPRECATION] #{old_method} is deprecated! Please, use #{new_method} instead\n"
+  end
+
+  it 'warns with deprecation message for AlphaCard::Sale' do
+    AlphaCard::Sale::ORIGIN_TRANSACTION_VARIABLES.each do |new, old|
+      expect { AlphaCard::Sale.new.send("#{old}=", 'T') }.to output(warn_writer(old, new)).to_stderr
+      expect { AlphaCard::Sale.new.send(old) }.to output(warn_reader(old, new)).to_stderr
+    end
+  end
+
+  it 'warns with deprecation message for AlphaCard::Billing' do
+    AlphaCard::Billing::ORIGIN_TRANSACTION_VARIABLES.each do |new, old|
+      expect { AlphaCard::Billing.new.send("#{old}=", 'T') }.to output(warn_writer(old, new)).to_stderr
+      expect { AlphaCard::Billing.new.send(old) }.to output(warn_reader(old, new)).to_stderr
+    end
+  end
+
+  it 'warns with deprecation message for AlphaCard::Shipping' do
+    AlphaCard::Shipping::ORIGIN_TRANSACTION_VARIABLES.each do |new, old|
+      expect { AlphaCard::Shipping.new.send("#{old}=", 'T') }.to output(warn_writer(old, new)).to_stderr
+      expect { AlphaCard::Shipping.new.send(old) }.to output(warn_reader(old, new)).to_stderr
+    end
+  end
+end

data/spec/alpha_card/objects/refund_spec.rb

@@ -0,0 +1,35 @@
+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') }
+
+    it 'response with error' do
+      expect { refund.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+    end
+  end
+
+  context 'with valid attributes' do
+    let(:refund) { AlphaCard::Refund.new(transaction_id: 'Some ID', amount: '10.05') }
+
+    it 'has valid request params' do
+      expected_params = {
+        transactionid: 'Some ID',
+        type: 'refund',
+        amount: '10.05'
+      }
+
+      expect(refund.attributes_for_request).to eq(expected_params)
+    end
+  end
+
+  context 'with blank attributes' do
+    let(:refund) { AlphaCard::Refund.new }
+
+    it 'raises an InvalidObject error' do
+      expect { refund.create(account) }.to raise_error(AlphaCard::InvalidObjectError)
+    end
+  end
+end

data/spec/alpha_card/objects/sale_spec.rb

@@ -0,0 +1,143 @@
+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(:order) { AlphaCard::Order.new(id: '1', description: 'Test', billing: billing, shipping: shipping) }
+  let(:card_exp) { "#{'%02d' % Time.now.month}/#{Time.now.year.next}" }
+
+  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',
+        ccnumber: '4111111111111111',
+        amount: '5.00',
+        payment: 'creditcard',
+        type: 'sale',
+        email: 'test@example.com',
+        address1: 'N',
+        address2: 'Y',
+        orderid: '1',
+        orderdescription: 'Test',
+        shipping_address_1: '22 N str.',
+        shipping_first_name: 'John',
+        shipping_last_name: 'Doe'
+      }
+
+      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
+    end
+  end
+
+  context 'with invalid Card number' do
+    let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: 'Invalid', 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 number must contain only digits')
+      end
+    end
+  end
+
+  context 'with invalid amount' do
+    let(:sale) { AlphaCard::Sale.new(card_expiration_date: card_exp, card_number: '4111111111111111', amount: '0.00') }
+
+    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
+    end
+  end
+
+  context 'with invalid Card expiration date' do
+    let(:sale) { AlphaCard::Sale.new(card_expiration_date: 'Invalid', 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
+    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') }
+
+    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
+    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') }
+
+    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
+    end
+  end
+
+  context 'without attributes' do
+    let(:sale) { AlphaCard::Sale.new }
+
+    it 'raises an InvalidObjectError exception' do
+      expect { sale.create(order, account) }.to raise_error(AlphaCard::InvalidObjectError)
+    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')
+      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(:sale) { AlphaCard::Sale.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 { sale.create(order, account) }.to raise_error(AlphaCard::APIConnectionError)
+
+        AlphaCard.api_base = 'https://secure.alphacardgateway.com/api/transact.php'
+      end
+    end
+  end
+end

data/spec/alpha_card/objects/update_spec.rb

@@ -0,0 +1,36 @@
+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') }
+
+    it 'response with error' do
+      expect { update.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+    end
+  end
+
+  context 'with valid attributes' do
+    let(:update) { AlphaCard::Update.new(transaction_id: 'Some ID', po_number: 'PO1', shipping: 'Test') }
+
+    it 'has valid request params' do
+      expected_params = {
+        transactionid: 'Some ID',
+        type: 'update',
+        ponumber: 'PO1',
+        shipping: 'Test'
+      }
+
+      expect(update.attributes_for_request).to eq(expected_params)
+    end
+  end
+
+  context 'with blank attributes' do
+    let(:update) { AlphaCard::Update.new }
+
+    it 'raises an InvalidObject error' do
+      expect { update.create(account) }.to raise_error(AlphaCard::InvalidObjectError)
+    end
+  end
+end

data/spec/alpha_card/objects/void_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe AlphaCard::Void do
+  let(:account) { AlphaCard::Account.new('demo', 'password') }
+
+  context 'with invalid attributes' do
+    let(:void) { AlphaCard::Void.new(transaction_id: 'Some ID') }
+
+    it 'response with error' do
+      expect { void.create(account) }.to raise_error(AlphaCard::AlphaCardError)
+    end
+  end
+
+  context 'with valid attributes' do
+    let(:void) { AlphaCard::Void.new(transaction_id: '2303767426') }
+
+    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') }
+
+    it 'has valid request params' do
+      expected_params = {
+        transactionid: '2303767426',
+        type: 'void'
+      }
+
+      expect(void.attributes_for_request).to eq(expected_params)
+    end
+
+    it 'processed successfully' do
+      success, response = sale.create(order, account)
+      expect(success).to be_truthy
+      expect(response.transaction_id).not_to be_nil
+
+      success, response = AlphaCard::Void.new(transaction_id: response.transaction_id).create(account)
+      expect(success).to be_truthy
+      expect(response.text).to eq('Transaction Void Successful')
+    end
+  end
+
+  context 'with blank attributes' do
+    let(:void) { AlphaCard::Void.new }
+
+    it 'raises an InvalidObject error' do
+      expect { void.create(account) }.to raise_error(AlphaCard::InvalidObjectError)
+    end
+  end
+end

data/spec/alpha_card/response_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe AlphaCard::AlphaCardResponse do
+  let(:successful_response_mock) do
+    'authcode=083319&avsresponse=&cvvresponse=M&orderid=1&response=1&response_code=100&responsetext=AP&transactionid=2303767426&type=sale'
+  end
+
+  let(:declined_response_mock) do
+    'authcode=&avsresponse=&cvvresponse=&orderid=1&response=2&response_code=220&responsetext=INVLD+ACCT&transactionid=2302720045&type=sale'
+  end
+
+  let(:error_response_mock) do
+    'authcode=&avsresponse=U&cvvresponse=&orderid=1&response=3&response_code=220&responsetext=ERROR&transactionid=2302620041&type=sale'
+  end
+
+  context 'successful request' do
+    let(:response) { AlphaCard::AlphaCardResponse.new(successful_response_mock) }
+
+    it '#success? = true' do
+      expect(response.success?).to be_truthy
+    end
+
+    it 'returns response code' do
+      expect(response.code).to eq('100')
+    end
+
+    it 'returns Transaction ID' do
+      expect(response.transaction_id).to eq('2303767426')
+    end
+
+    it 'returns CVV response message' do
+      expect(response.cvv_response).to eq('CVV2/CVC2 match')
+    end
+
+    it 'returns blank AVS response message' do
+      expect(response.avs_response).to be_nil
+    end
+
+    it 'returns Order ID' do
+      expect(response.order_id).to eq('1')
+    end
+
+    it 'returns response message' do
+      expect(response.message).to eq('Transaction was approved')
+    end
+
+    it 'returns auth code' do
+      expect(response.auth_code).to eq('083319')
+    end
+  end
+
+  context 'declined request' do
+    let(:response) { AlphaCard::AlphaCardResponse.new(declined_response_mock) }
+
+    it '#declined? = true' do
+      expect(response.declined?).to be_truthy
+    end
+
+    it 'returns responce code' do
+      expect(response.code).to eq('220')
+    end
+
+    it 'returns Transaction ID' do
+      expect(response.transaction_id).to eq('2302720045')
+    end
+
+    it 'returns Order ID' do
+      expect(response.order_id).to eq('1')
+    end
+
+    it 'returns response message' do
+      expect(response.message).to eq('Incorrect payment information')
+    end
+
+    it "doesn't returns auth code" do
+      expect(response.auth_code).to be_nil.or(be_empty)
+    end
+  end
+
+  context 'error request' do
+    let(:response) { AlphaCard::AlphaCardResponse.new(error_response_mock) }
+
+    it '#error? = true' do
+      expect(response.error?).to be_truthy
+    end
+
+    it 'returns responce code' do
+      expect(response.code).to eq('220')
+    end
+
+    it 'returns Transaction ID' do
+      expect(response.transaction_id).to eq('2302620041')
+    end
+
+    it 'returns Order ID' do
+      expect(response.order_id).to eq('1')
+    end
+
+    it 'returns AVS response message' do
+      expect(response.avs_response).to eq('Address unavailable')
+    end
+
+    it 'returns response message' do
+      expect(response.message).to eq('Incorrect payment information')
+    end
+
+    it "doesn't returns auth code" do
+      expect(response.auth_code).to be_nil.or(be_empty)
+    end
+  end
+end