rocketgate-ruby 0.0.1.pre

data/spec/request_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe RocketGate::Request do
+  describe '.new' do
+    subject { RocketGate::Request.new(transaction) }
+
+    let(:transaction) { double(:transaction) }
+
+    it 'sets the transaction' do
+      expect(subject.transaction).to eq transaction
+    end
+  end
+
+  describe '#base_parameters' do
+    subject { request.base_parameters }
+    let(:request) { RocketGate::Request.new }
+
+    before { config.testing! }
+
+    let(:config) { RocketGate.configuration }
+
+    it 'returns a hash that respects configuration' do
+      expect(subject[:version]).to eq 'R1.2'
+      expect(subject[:merchantID]).to eq '1'
+      expect(subject[:merchantPassword]).to eq 'testpassword'
+      expect(subject[:avsCheck]).to eq 'YES'
+      expect(subject[:cvv2Check]).to eq 'YES'
+      expect(subject[:scrub]).to eq 'YES'
+    end
+
+    context 'when the transaction is referenced' do
+      before { request.transaction = double(:transaction, is_referenced?: true) }
+
+      it 'does not include AVS, CVV or Scrub configuration' do
+        expect(subject[:version]).to eq 'R1.2'
+        expect(subject[:merchantID]).to eq '1'
+        expect(subject[:merchantPassword]).to eq 'testpassword'
+      end
+    end
+  end
+
+  describe '#build_gateway_request' do
+    subject { RocketGate::Request.new(transaction).build_gateway_request }
+    let(:transaction) do
+      RocketGate::Transaction.new.tap do |tx|
+        tx.amount = 10.97
+        tx.currency = 'GBP'
+        tx.id = 'abbb2170-6a71-4d96-aa8f-ceb8b7d1a7ca'
+
+        tx.customer = RocketGate::Customer.new.tap do |cust|
+          cust.id = 'Customer-1'
+          cust.first_name = 'Test'
+          cust.last_name = 'Person'
+          cust.street_address = '123 Fake Street'
+          cust.city = 'Beverly Hills'
+          cust.state = 'CA'
+          cust.postal_code = '90210'
+          cust.country = 'US'
+          cust.email = 'test@example.com'
+          cust.ip_address = '127.0.0.1'
+        end
+
+        tx.credit_card = RocketGate::CreditCard.new.tap do |cc|
+          cc.number = '4111111111111111'
+          cc.exp_month = '02'
+          cc.exp_year = '2015'
+          cc.cvv = '999'
+        end
+      end
+    end
+
+    before do
+      RocketGate.configuration.testing!
+      RocketGate.configuration.require_avs = false
+    end
+
+    it 'matches the expected xml output' do
+      expected = %Q{<?xml version="1.0" encoding="UTF-8"?><gatewayRequest><version>R1.2</version><merchantID>1</merchantID><merchantPassword>testpassword</merchantPassword><avsCheck>IGNORE</avsCheck><cvv2Check>YES</cvv2Check><scrub>YES</scrub><amount>10.97</amount><currency>GBP</currency><merchantInvoiceID>abbb2170-6a71-4d96-aa8f-ceb8b7d1a7ca</merchantInvoiceID><transactionType>CC_AUTH</transactionType><cardNo>4111111111111111</cardNo><expireMonth>02</expireMonth><expireYear>2015</expireYear><cvv2>999</cvv2><merchantCustomerID>Customer-1</merchantCustomerID><customerFirstName>Test</customerFirstName><customerLastName>Person</customerLastName><billingAddress>123 Fake Street</billingAddress><billingCity>Beverly Hills</billingCity><billingState>CA</billingState><billingZipCode>90210</billingZipCode><billingCountry>US</billingCountry><email>test@example.com</email><ipAddress>127.0.0.1</ipAddress></gatewayRequest>}
+      expect(subject).to eq expected
+    end
+  end
+
+  describe '#yes_or_ignore' do
+    it 'returns yes for true' do
+      expect(RocketGate::Request.new.yes_or_ignore(true)).to eq 'YES'
+    end
+
+    it 'returns ignore for false' do
+      expect(RocketGate::Request.new.yes_or_ignore(false)).to eq 'IGNORE'
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe RocketGate::Response do
+  before { RocketGate.configuration.testing! }
+
+  let(:xml) { '<?xml version="1.0" encoding="UTF-8"?><gatewayResponse><cardType>VISA</cardType><approvedAmount>9.99</approvedAmount><retrievalNo>1000148e87eab19</retrievalNo><approvedCurrency>USD</approvedCurrency><reasonCode>0</reasonCode><merchantAccount>1</merchantAccount><version>1.0</version><cardLastFour>1111</cardLastFour><cardHash>m77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24=</cardHash><guidNo>1000148E87EAB19</guidNo><responseCode>0</responseCode><authNo>892343</authNo><cardExpiration>0210</cardExpiration><payType>CREDIT</payType></gatewayResponse>' }
+
+  describe '.from_xml' do
+    subject { RocketGate::Response.from_xml(xml) }
+    let(:response) { RocketGate::Response.new }
+
+    it 'builds a new instance with the xml document' do
+      expect(RocketGate::Response).to receive(:new).and_return(response)
+      expect(Nokogiri).to receive(:parse).with(xml).and_call_original
+      expect(response).to receive(:xml_document=).with(an_instance_of(Nokogiri::XML::Document))
+      expect(response).to receive(:build!)
+      subject
+    end
+  end
+
+  describe '#build!' do
+    subject { response.build! }
+    let(:response) { RocketGate::Response.new.tap{|r| r.xml_document = Nokogiri.parse(xml) } }
+    let(:authorization) { RocketGate::Authorization.new }
+
+    before { allow(RocketGate::Authorization).to receive(:new).and_return(authorization) }
+
+    it 'fills in the response code' do
+      expect{subject}.to change{response.response_code}.from(nil).to(:success)
+    end
+
+    it 'builds an authorization' do
+      expect{subject}.to change{response.authorization}
+        .from(nil).to(authorization)
+
+      expect(authorization.approved_amount).to eq 9.99
+      expect(authorization.approved_currency).to eq 'USD'
+      expect(authorization.auth_code).to eq '892343'
+      expect(authorization.avs_response).to be_nil
+      expect(authorization.card_expiration).to eq '0210'
+      expect(authorization.card_hash).to eq 'm77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24='
+      expect(authorization.card_last_four).to eq '1111'
+      expect(authorization.cvv_response).to be_nil
+      expect(authorization.reason_code).to eq :success
+      expect(authorization.reference_id).to eq '1000148E87EAB19'
+    end
+  end
+
+  describe '#confirm!' do
+    subject { response.confirm! }
+    let(:response) { RocketGate::Response.from_xml(xml) }
+
+    before do
+      allow(response).to receive(:success?).and_return(success)
+      allow(RocketGate).to receive(:send_request!).and_return(:ok)
+    end
+
+    context 'when the request was successful' do
+      let(:success) { true }
+      let(:transaction) { RocketGate::Transaction.new }
+
+      before { allow(RocketGate::Transaction).to receive(:new).and_return(transaction) }
+
+      it 'builds a confirmation transaction' do
+        expect(RocketGate::Transaction).to receive(:new)
+        expect(transaction).to receive(:reference_id=)
+          .with('1000148E87EAB19').and_call_original
+        expect(transaction).to receive(:type=)
+          .with(RocketGate::Transaction::TYPE[:confirmation]).and_call_original
+        expect(RocketGate::Request).to receive(:new)
+          .with(transaction).and_call_original
+
+        subject
+      end
+
+      it 'sends the confirmation transaction' do
+        expect(RocketGate).to receive(:send_request!).with(an_instance_of(RocketGate::Request))
+        subject
+      end
+
+      it 'returns the confirmation response' do
+        allow(RocketGate).to receive(:send_request!).and_return(response)
+        expect(subject).to eq response
+      end
+    end
+
+    context 'when the request was not successful' do
+      let(:success) { false }
+
+      it 'raises an error' do
+        expect{subject}.to raise_error(RocketGate::AuthorizationError, 'Unable to confirm unauthorized transaction')
+      end
+    end
+  end
+
+  describe '#authorized?' do
+    subject { response.authorized? }
+    let(:response) { RocketGate::Response.new }
+
+    context 'when there is a successful authorization' do
+      before { response.authorization = double(:authorization, success?: true) }
+
+      it 'returns true' do
+        expect(subject).to be true
+      end
+    end
+
+    context 'when there is an unsuccessful authorization' do
+      before { response.authorization = double(:authorization, success?: false) }
+
+      it 'returns true' do
+        expect(subject).to be false
+      end
+    end
+
+    context 'when there is no authorization' do
+      before { response.authorization = nil }
+
+      it 'returns true' do
+        expect(subject).to be false
+      end
+    end
+  end
+
+  describe '#success?' do
+    subject { response.success? }
+    let(:response) { RocketGate::Response.new }
+
+    before do
+      allow(response).to receive(:authorized?).and_return(authorized)
+      response.response_code = response_code
+    end
+
+    context 'when the request was authorized' do
+      let(:authorized) { true }
+      let(:response_code) { :success }
+
+      it 'returns true' do
+        expect(subject).to be true
+      end
+    end
+
+    context 'when the request was not authorized' do
+      let(:authorized) { false }
+      let(:response_code) { :success }
+
+      it 'returns false' do
+        expect(subject).to be false
+      end
+    end
+
+    context 'when the request was not successful' do
+      let(:authorized) { true }
+      let(:response_code) { :bank_decline }
+
+      it 'returns false' do
+        expect(subject).to be false
+      end
+    end
+  end
+
+  describe '#find_value' do
+    subject { response.send(:find_value, key) }
+    let(:response) { RocketGate::Response.from_xml(xml) }
+
+    context 'when the key is present' do
+      let(:key) { 'authNo' }
+
+      it 'returns the corresponding value' do
+        expect(subject).to eq '892343'
+      end
+    end
+
+    context 'when the key is not present' do
+      let(:key) { 'missingKey' }
+
+      it 'returns nothing' do
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'when the response is not what we expect' do
+      let(:xml) { '<?xml version="1.0" encoding="UTF-8"?><unexpectedDocument />' }
+
+      it 'raises an error' do
+        expect{subject}.to raise_error(RocketGate::GatewayResponseError, 'Unexpected response format')
+      end
+    end
+  end
+end

data/spec/rocketgate_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe RocketGate do
+  describe '.configuration' do
+    subject { RocketGate.configuration }
+
+    context 'when configuration is available' do
+      before { RocketGate.configure {|c| c.merchant_id = '123' } }
+
+      it 'returns it' do
+        expect(RocketGate::Configuration).not_to receive(:new)
+        expect(subject.merchant_id).to eq '123'
+      end
+    end
+
+    context 'when configuration is not available' do
+      before { RocketGate.reset! }
+
+      it 'supplies a default config' do
+        expect(subject.request_host).to eq RocketGate::Configuration::GATEWAY_LIVE_HOST
+      end
+    end
+  end
+
+  describe '.configure' do
+    subject { RocketGate.configure {|c| c.require_avs = false } }
+    let(:config) { RocketGate.configuration }
+
+    it 'applies settings from a config block' do
+      expect{subject}.to change{config.require_avs}.from(true).to(false)
+    end
+  end
+
+  describe '.connection' do
+    subject { RocketGate.connection }
+    let(:config) { RocketGate.configuration }
+
+    before { config.testing! }
+
+    it 'validates the configuration' do
+      expect(config).to receive(:validate!)
+      subject
+    end
+
+    it 'returns a connection' do
+      expect(RocketGate::Connection).to receive(:new)
+        .with(config.request_host, config.request_port, config.request_path)
+        .and_call_original
+      expect(subject).to be_an_instance_of(RocketGate::Connection)
+    end
+  end
+
+  describe '.reset!' do
+    subject { RocketGate.reset! }
+    before do
+      RocketGate.configuration.testing!
+      RocketGate.connection
+    end
+
+    it 'clears the memoized configuration' do
+      expect(RocketGate.instance_variable_get(:@configuration)).not_to be_nil
+      subject
+      expect(RocketGate.instance_variable_get(:@configuration)).to be_nil
+    end
+
+    it 'clears the memoized connection' do
+      expect(RocketGate.instance_variable_get(:@connection)).not_to be_nil
+      subject
+      expect(RocketGate.instance_variable_get(:@connection)).to be_nil
+    end
+  end
+
+  describe '.send_request!' do
+    subject { RocketGate.send_request!(request) }
+
+    before do
+      RocketGate.configuration.testing!
+      allow(RocketGate.connection).to receive(:make_request!).and_return(response)
+    end
+
+    let(:request) { double(:request, build_gateway_request: 'request') }
+    let(:response) { double(:response, code: 200, body: xml) }
+    let(:xml) { '<?xml version="1.0" encoding="UTF-8"?><gatewayResponse><cardType>VISA</cardType><approvedAmount>9.99</approvedAmount><retrievalNo>1000148e87eab19</retrievalNo><approvedCurrency>USD</approvedCurrency><reasonCode>0</reasonCode><merchantAccount>1</merchantAccount><version>1.0</version><cardLastFour>1111</cardLastFour><cardHash>m77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24=</cardHash><guidNo>1000148E87EAB19</guidNo><responseCode>0</responseCode><authNo>892343</authNo><cardExpiration>0210</cardExpiration><payType>CREDIT</payType></gatewayResponse>' }
+
+    it 'sends the request via the connection' do
+      expect(RocketGate.connection).to receive(:make_request!).with('request')
+      subject
+    end
+
+    it 'builds a response object from the parsed body' do
+      expect(RocketGate::Response).to receive(:from_xml).with(xml).and_call_original
+
+      subject
+    end
+
+    it 'does not raise an error' do
+      expect{subject}.not_to raise_error
+    end
+
+    context 'when the request was unsuccessful' do
+      before { allow(response).to receive(:code).and_return(500) }
+
+      it 'raises an error' do
+        expect{subject}.to raise_error(RocketGate::GatewayRequestError, 'Unexpected status code in gateway response: 500')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'pry'
+require 'rocketgate'
+
+RSpec.configure do |config|
+  config.before(:each) { RocketGate.reset! }
+end

data/spec/transaction_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe RocketGate::Transaction do
+  describe '.new' do
+    let(:customer) { double(:customer) }
+    let(:credit_card) { double(:credit_card) }
+
+    it 'accepts an arbitrary set of arguments and assigns them to certain attributes' do
+      transaction = RocketGate::Transaction.new(12.34, customer, credit_card, 'GBP')
+      expect(transaction.amount).to eq 12.34
+      expect(transaction.customer).to eq customer
+      expect(transaction.credit_card).to eq credit_card
+      expect(transaction.currency).to eq 'GBP'
+    end
+  end
+
+  describe '#credit_card_hash' do
+    subject { transaction.credit_card_hash }
+    let(:transaction) do
+      RocketGate::Transaction.new.tap {|tx| tx.credit_card = credit_card }
+    end
+    let(:credit_card) { double(:credit_card) }
+
+    it 'delegates to the credit card' do
+      expect(credit_card).to receive(:to_hash)
+      subject
+    end
+  end
+
+  describe '#customer_hash' do
+    subject { transaction.customer_hash }
+    let(:transaction) do
+      RocketGate::Transaction.new.tap {|tx| tx.customer = customer }
+    end
+    let(:customer) { double(:customer) }
+
+    it 'delegates to the customer' do
+      expect(customer).to receive(:to_hash)
+      subject
+    end
+  end
+
+  describe '#id' do
+    let(:transaction) { RocketGate::Transaction.new }
+
+    it 'returns the supplied ID when set' do
+      transaction.id = 'abc123'
+      expect(transaction.id).to eq 'abc123'
+    end
+
+    it 'generates a random UUID when not set' do
+      expect(SecureRandom).to receive(:uuid).and_return('def456')
+      expect(transaction.id).to eq 'def456'
+    end
+  end
+
+  describe '#is_referenced?' do
+    let(:transaction) do
+      RocketGate::Transaction.new.tap do |tx|
+        tx.reference_id = 'abc123'
+        tx.type         = type
+      end
+    end
+
+    context 'when it is a ticket transaction' do
+      let(:type) { RocketGate::Transaction::TYPE[:ticket] }
+
+      it 'returns true' do
+        expect(transaction.is_referenced?).to eq true
+      end
+    end
+
+    context 'when it is a void transaction' do
+      let(:type) { RocketGate::Transaction::TYPE[:void] }
+
+      it 'returns true' do
+        expect(transaction.is_referenced?).to eq true
+      end
+    end
+
+    context 'when it is not a referenced transaction' do
+      let(:type) { RocketGate::Transaction::TYPE[:auth] }
+
+      it 'returns true' do
+        expect(transaction.is_referenced?).to eq false
+      end
+    end
+  end
+
+  describe '#type' do
+    let(:transaction) { RocketGate::Transaction.new }
+
+    it 'returns auth type by default' do
+      expect(transaction.type).to eq RocketGate::Transaction::TYPE[:auth]
+    end
+
+    it 'returns the assigned value when set' do
+      transaction.type = RocketGate::Transaction::TYPE[:purchase]
+      expect(transaction.type).to eq RocketGate::Transaction::TYPE[:purchase]
+    end
+  end
+
+  describe '#type=' do
+    let(:transaction) { RocketGate::Transaction.new }
+
+    it 'converts symbols to their associated string values' do
+      transaction.type = :auth
+      expect(transaction.type).to eq RocketGate::Transaction::TYPE[:auth]
+    end
+
+    it 'raises an error if an unknown type is specified' do
+      expect{ transaction.type = :fake_type }.to raise_error(RocketGate::ValidationError, 'Unknown transaction type: fake_type')
+      expect{ transaction.type = 'FAKETYPE' }.to raise_error(RocketGate::ValidationError, 'Unknown transaction type: FAKETYPE')
+    end
+  end
+
+  describe '#to_hash' do
+    context 'when it is a standard transaction' do
+      let(:transaction) do
+        RocketGate::Transaction.new.tap do |tx|
+          tx.id                 = '90c3e1d8-14f0-4aea-9eda-a7a59396e264'
+          tx.amount             = 12.34
+          tx.type               = RocketGate::Transaction::TYPE[:auth]
+
+          tx.customer = RocketGate::Customer.new.tap do |cust|
+            cust.id             = '07f7b231-9b29-46d4-9c19-cd6790e712b5'
+            cust.first_name     = 'Test'
+            cust.last_name      = 'Person'
+            cust.street_address = '123 Fake Street'
+            cust.city           = 'Beverly Hills'
+            cust.state          = 'CA'
+            cust.postal_code    = '90210'
+            cust.country        = 'US'
+            cust.email          = 'test@example.com'
+            cust.username       = 'tester'
+            cust.ip_address     = '127.0.0.1'
+          end
+
+          tx.credit_card = RocketGate::CreditCard.new.tap do |cc|
+            cc.number           = '4111111111111111'
+            cc.exp_month        = '01'
+            cc.exp_year         = '2020'
+            cc.cvv              = '999'
+          end
+        end
+      end
+
+      let(:expected) do
+        {
+          cardNo: '4111111111111111',
+          expireMonth: '01',
+          expireYear: '2020',
+          cvv2: '999',
+          amount: 12.34,
+          currency: 'USD',
+          merchantCustomerID: '07f7b231-9b29-46d4-9c19-cd6790e712b5',
+          merchantInvoiceID: '90c3e1d8-14f0-4aea-9eda-a7a59396e264',
+          customerFirstName: 'Test',
+          customerLastName: 'Person',
+          billingAddress: '123 Fake Street',
+          billingCity: 'Beverly Hills',
+          billingState: 'CA',
+          billingZipCode: '90210',
+          billingCountry: 'US',
+          email: 'test@example.com',
+          username: 'tester',
+          ipAddress: '127.0.0.1',
+          referenceGUID: nil,
+          transactionType: 'CC_AUTH'
+        }
+      end
+
+      it 'returns a hash of the transaction attributes' do
+        expect(transaction.to_hash).to eq expected
+      end
+    end
+
+    context 'when it is a ticket transaction' do
+      let(:transaction) do
+        RocketGate::Transaction.new.tap do |tx|
+          tx.reference_id = 'abc123'
+          tx.type         = RocketGate::Transaction::TYPE[:ticket]
+        end
+      end
+
+      let(:expected) do
+        { referenceGUID: 'abc123', transactionType: 'CC_TICKET' }
+      end
+
+      it 'returns only the reference id and type' do
+        expect(transaction.to_hash).to eq expected
+      end
+    end
+
+    context 'when it is a void transaction' do
+      let(:transaction) do
+        RocketGate::Transaction.new.tap do |tx|
+          tx.reference_id = 'abc123'
+          tx.type         = RocketGate::Transaction::TYPE[:void]
+        end
+      end
+
+      let(:expected) do
+        { referenceGUID: 'abc123', transactionType: 'CC_VOID' }
+      end
+
+      it 'returns only the reference id and type' do
+        expect(transaction.to_hash).to eq expected
+      end
+    end
+
+    context 'when it is a confirmation' do
+      let(:transaction) do
+        RocketGate::Transaction.new.tap do |tx|
+          tx.reference_id = 'abc123'
+          tx.type         = RocketGate::Transaction::TYPE[:confirmation]
+        end
+      end
+
+      let(:expected) do
+        { referenceGUID: 'abc123', transactionType: 'CC_CONFIRM' }
+      end
+
+      it 'returns only the reference id and type' do
+        expect(transaction.to_hash).to eq expected
+      end
+    end
+  end
+
+  describe '#valid?' do
+    subject { transaction.valid? }
+    context 'when it is a referenced transaction' do
+      let(:transaction) { RocketGate::Transaction.new }
+      before { allow(transaction).to receive(:is_referenced?).and_return(true) }
+
+      it 'bypasses normal validation rules' do
+        expect(subject).to be true
+      end
+    end
+
+    context 'when it is a standard transaction' do
+      let(:transaction) { RocketGate::Transaction.new }
+      before { allow(transaction).to receive(:is_referenced?).and_return(false) }
+
+      it 'defers to normal validation rules' do
+        expect(subject).to be false
+      end
+    end
+  end
+end