rocketgate-ruby 0.0.1.pre

data/lib/rocketgate/version.rb

@@ -0,0 +1,3 @@
+module RocketGate
+  VERSION = "0.0.1.pre"
+end

data/rocketgate-ruby.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rocketgate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rocketgate-ruby"
+  spec.version       = RocketGate::VERSION
+  spec.authors       = ["Chris Cashwell"]
+  spec.email         = ["ccashwell@gmail.com"]
+  spec.summary       = %q{RocketGate Payment Gateway integration for Ruby}
+  spec.description   = %q{rocketgate-ruby is a simple interface for communicating with RocketGate's Payment Gateway}
+  spec.homepage      = "https://github.com/ccashwell/rocketgate-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "pry-remote"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "rspec"
+
+  spec.add_runtime_dependency     "gyoku"
+  spec.add_runtime_dependency     "nokogiri"
+end

data/spec/authorization_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe RocketGate::Authorization do
+  let(:authorization) { RocketGate::Authorization.new }
+
+  describe '#avs_ok?' do
+    subject { authorization.avs_ok? }
+
+    context 'when AVS verification is required' do
+      before { RocketGate.configuration.require_avs = true }
+
+      it 'returns true when the AVS check was successful' do
+        authorization.avs_response = :match
+        expect(subject).to be true
+      end
+
+      it 'returns false when the AVS check was unsuccessful' do
+        authorization.avs_response = :no_match
+        expect(subject).to be false
+      end
+    end
+
+    context 'when AVS verification is not required' do
+      before { RocketGate.configuration.require_avs = false }
+
+      it 'returns true' do
+        expect(subject).to be true
+      end
+    end
+  end
+
+  describe '#cvv_ok?' do
+    subject { authorization.cvv_ok? }
+
+    context 'when CVV verification is required' do
+      before { RocketGate.configuration.require_cvv = true }
+
+      it 'returns true when the CVV check was successful' do
+        authorization.cvv_response = :match
+        expect(subject).to be true
+      end
+
+      it 'returns false when the CVV check was unsuccessful' do
+        authorization.cvv_response = :no_match
+        expect(subject).to be false
+      end
+    end
+
+    context 'when CVV verification is not required' do
+      before { RocketGate.configuration.require_cvv = false }
+
+      it 'returns true' do
+        expect(subject).to be true
+      end
+    end
+  end
+
+  describe '#declined?' do
+    subject { authorization.declined? }
+
+    it 'returns true when successful' do
+      allow(authorization).to receive(:success?).and_return(true)
+      expect(subject).to be false
+    end
+
+    it 'returns false when unsuccessful' do
+      allow(authorization).to receive(:success?).and_return(false)
+      expect(subject).to be true
+    end
+  end
+
+  describe '#success?' do
+    subject { authorization.success? }
+
+    it 'returns true when everything is ok' do
+      allow(authorization).to receive(:avs_ok?).and_return(true)
+      allow(authorization).to receive(:cvv_ok?).and_return(true)
+      allow(authorization).to receive(:reason_code).and_return(:success)
+      expect(subject).to be true
+    end
+
+    it 'returns false when anything is not ok' do
+      allow(authorization).to receive(:avs_ok?).and_return(false)
+      expect(subject).to be false
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe RocketGate::Configuration do
+  describe '#initialize' do
+    let(:config) { RocketGate::Configuration.new }
+
+    it 'supplies a reasonable default config' do
+      expect(config.currency).to eq RocketGate::Configuration::DEFAULT_CURRENCY
+      expect(config.request_host).to eq RocketGate::Configuration::GATEWAY_LIVE_HOST
+      expect(config.request_path).to eq RocketGate::Configuration::GATEWAY_SERVLET
+      expect(config.request_port).to eq RocketGate::Configuration::GATEWAY_PORT
+      expect(config.request_timeout).to eq RocketGate::Configuration::DEFAULT_TIMEOUT
+      expect(config.request_version).to eq RocketGate::Configuration::GATEWAY_VERSION
+      expect(config.require_avs).to eq true
+      expect(config.require_cvv).to eq true
+      expect(config.require_scrub).to eq true
+      expect(config.require_ssl).to eq true
+    end
+  end
+
+  describe '#testing!' do
+    subject { config.testing! }
+
+    let(:config) { RocketGate::Configuration.new }
+
+    it 'sets up the default testing configuration' do
+      expect(subject).to eq config
+      expect(config.request_host).to eq RocketGate::Configuration::GATEWAY_TEST_HOST
+      expect(config.merchant_id).to eq '1'
+      expect(config.merchant_password).to eq 'testpassword'
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe RocketGate::Connection do
+  before { allow(Net::HTTP).to receive(:new).and_return(client) }
+  let(:client) { Net::HTTP.new('insecure.com', 80) }
+
+  describe '.new' do
+    subject { RocketGate::Connection.new('example.com', 443, '/path') }
+
+    it 'instantiates a client' do
+      expect(Net::HTTP).to receive(:new).with('example.com', 443)
+      subject
+    end
+
+    it 'sets the request timeouts' do
+      expect(client).to receive(:open_timeout=).with(10)
+      expect(client).to receive(:read_timeout=).with(10)
+      subject
+    end
+
+    context 'when SSL is required' do
+      before { RocketGate.configuration.require_ssl = true }
+
+      it 'uses SSL, VERIFY_NONE mode' do
+        expect(client).to receive(:use_ssl=).with(true)
+        expect(client).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+        subject
+      end
+    end
+
+    context 'when SSL is not required' do
+      before { RocketGate.configuration.require_ssl = false }
+
+      it 'uses SSL, VERIFY_NONE mode' do
+        expect(client).not_to receive(:use_ssl=)
+        expect(client).not_to receive(:verify_mode=)
+        subject
+      end
+    end
+  end
+
+  describe '#make_request!' do
+    subject { RocketGate::Connection.new('example.com', 443, '/path').make_request!('test') }
+    let(:request) { double(:post).as_null_object }
+    before do
+      allow(Net::HTTP::Post).to receive(:new).and_return(request)
+      allow(client).to receive(:request).with(request)
+    end
+
+    it 'builds a request' do
+      expect(Net::HTTP::Post).to receive(:new).with('/path', {
+        'Accept'       => 'text/xml',
+        'Content-Type' => 'text/xml',
+        'User-Agent'   => 'rocketgate-ruby/0.0.1.pre'
+      }).and_return(request)
+      expect(request).to receive(:body=).with('test')
+      subject
+    end
+
+    it 'sends the request' do
+      expect(client).to receive(:request).with(request)
+      subject
+    end
+  end
+end

data/spec/credit_card_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe RocketGate::CreditCard do
+  describe '.new' do
+    it 'accepts an arbitrary set of arguments and assigns them to certain attributes' do
+      credit_card = RocketGate::CreditCard.new('4111111111111111', '01', '2015', '123')
+      expect(credit_card.number).to eq '4111111111111111'
+      expect(credit_card.exp_month).to eq '01'
+      expect(credit_card.exp_year).to eq '2015'
+      expect(credit_card.cvv).to eq '123'
+    end
+
+    it 'cleans the card number' do
+      expect(RocketGate::CreditCard.new('4111-2222-3333-4444').number).to eq '4111222233334444'
+      expect(RocketGate::CreditCard.new('4444 5555 6666 7777').number).to eq '4444555566667777'
+    end
+  end
+
+  describe '.from_card_hash' do
+    it 'instantiates a card with the hash' do
+      credit_card = RocketGate::CreditCard.from_card_hash('m77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24=')
+      expect(credit_card.card_hash).to eq 'm77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24='
+    end
+  end
+
+  describe '#to_hash' do
+    let(:credit_card) { RocketGate::CreditCard.new('4111111111111111', '01', '2015', '123') }
+
+    context 'when there is a card hash available' do
+      before { credit_card.card_hash = 'm77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24=' }
+
+      it 'returns a hash which only includes the card hash' do
+        expect(credit_card.to_hash).to eq({ cardHash: 'm77xlHZiPKVsF9p1/VdzTb+CUwaGBDpuSRxtcb7+j24=' })
+      end
+    end
+
+    context 'when there is no card hash available' do
+      it 'returns a hash of the card attributes' do
+        expect(credit_card.to_hash).to eq({
+          cardNo: '4111111111111111',
+          expireMonth: '01',
+          expireYear: '2015',
+          cvv2: '123'
+        })
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'when there is a card hash' do
+      let(:credit_card) { RocketGate::CreditCard.new.tap{|cc| cc.card_hash = 'abc' } }
+
+      it 'is true' do
+        expect(credit_card.valid?).to eq true
+      end
+    end
+
+    context 'when there is not a card hash' do
+      let(:credit_card) { RocketGate::CreditCard.new }
+
+      it 'validates the other attributes' do
+        expect(credit_card.valid?).to eq false
+
+        credit_card.number = '4111111111111111',
+        credit_card.exp_month = '01'
+        credit_card.exp_year = '2015'
+        credit_card.cvv = '123'
+
+        expect(credit_card.valid?).to eq true
+      end
+    end
+  end
+end

data/spec/customer_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe RocketGate::Customer do
+  describe '.new' do
+    it 'accepts an arbitrary set of arguments and assigns them to certain attributes' do
+      customer = RocketGate::Customer.new('Test', 'Person', '123 Fake Street', 'Beverly Hills', 'CA', '90210', 'US', 'test@example.com', 'tester', '127.0.0.1', '07f7b231-9b29-46d4-9c19-cd6790e712b5')
+      expect(customer.first_name).to eq 'Test'
+      expect(customer.last_name).to eq 'Person'
+      expect(customer.street_address).to eq '123 Fake Street'
+      expect(customer.city).to eq 'Beverly Hills'
+      expect(customer.state).to eq 'CA'
+      expect(customer.postal_code).to eq '90210'
+      expect(customer.country).to eq 'US'
+      expect(customer.email).to eq 'test@example.com'
+      expect(customer.username).to eq 'tester'
+      expect(customer.ip_address).to eq '127.0.0.1'
+      expect(customer.id).to eq '07f7b231-9b29-46d4-9c19-cd6790e712b5'
+    end
+  end
+
+  describe '#id' do
+    let(:customer) { RocketGate::Customer.new }
+
+    it 'returns the supplied ID when set' do
+      customer.id = 'abc123'
+      expect(customer.id).to eq 'abc123'
+    end
+
+    it 'generates a random UUID when not set' do
+      expect(SecureRandom).to receive(:uuid).and_return('07f7b231-9b29-46d4-9c19-cd6790e712b5')
+      expect(customer.id).to eq '07f7b231-9b29-46d4-9c19-cd6790e712b5'
+    end
+  end
+
+  describe '#to_hash' do
+    let(:customer) { RocketGate::Customer.new('Test', 'Person', '123 Fake Street', 'Beverly Hills', 'CA', '90210', 'US', 'test@example.com', 'tester', '127.0.0.1', '07f7b231-9b29-46d4-9c19-cd6790e712b5') }
+    let(:expected) do
+      {
+        merchantCustomerID: '07f7b231-9b29-46d4-9c19-cd6790e712b5',
+        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'
+      }
+    end
+
+    it 'returns a hash of the customer attributes' do
+      expect(customer.to_hash).to eq expected
+    end
+  end
+end

data/spec/hashable_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe RocketGate::Hashable do
+  describe '.hashable' do
+    let(:test_class) { Class.new }
+
+    it 'records a hash of display names and their attribute mappings' do
+      expect(test_class).to receive(:hashable).with({:One => :one, "two" => :two})
+      test_class.class_eval do
+        include RocketGate::Hashable
+        attr_accessor :one, :two, :three
+        hashable({:One => :one, "two" => :two})
+      end
+    end
+
+    it 'records a list of mergable items appearing after the mappings' do
+      expect(test_class).to receive(:hashable).with({one: :one}, :two, :three)
+      test_class.class_eval do
+        include RocketGate::Hashable
+        attr_accessor :one, :two, :three
+        hashable({one: :one}, :two, :three)
+      end
+    end
+
+    it 'allows display names to be mapped to procs' do
+      expect(test_class).to receive(:hashable).with({one: an_instance_of(Proc)})
+      expect do
+        test_class.class_eval do
+          include RocketGate::Hashable
+          hashable({one: Proc.new { true } })
+        end
+      end.not_to raise_error
+    end
+
+    it 'allows mergable items to procs' do
+      expect(test_class).to receive(:hashable).with({one: :one}, an_instance_of(Proc))
+      expect do
+        test_class.class_eval do
+          include RocketGate::Hashable
+          attr_accessor :one
+          hashable({one: :one}, Proc.new { true })
+        end
+      end.not_to raise_error
+    end
+
+    it 'complains about display names mapped to attributes that are not real' do
+      expect do
+        test_class.class_eval do
+          include RocketGate::Hashable
+          attr_accessor :one, :two
+          hashable({:One => :one, "two" => :two, "3" => :three})
+        end
+      end.to raise_error(RocketGate::ValidationError, 'Invalid attribute: three')
+    end
+
+    it 'complains about mergable items which are not real' do
+      expect do
+        test_class.class_eval do
+          include RocketGate::Hashable
+          attr_accessor :one, :two
+          hashable({one: :one}, :two, :three)
+        end
+      end.to raise_error(RocketGate::ValidationError, 'Invalid attribute: three')
+    end
+  end
+
+  describe '#to_hash' do
+    let(:test_class) do
+      c = Class.new
+      c.class_eval do
+        include RocketGate::Hashable
+        attr_accessor :one, :two
+        define_method :three do
+          { "3" => 1+2 }
+        end
+        hashable({one: :one, 'Two' => :two}, :three, ->{ { four: 4 } })
+      end
+      c.new
+    end
+
+    it 'builds a hash using the mappings and mergables provided' do
+      expect(test_class.to_hash).to eq({one: nil, 'Two' => nil, '3' => 3, four: 4})
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe 'RocketGate Integration Certification Test Cases', integration: true do
+  before do
+    RocketGate.configuration.testing!
+    RocketGate.configuration.require_scrub = false
+  end
+
+  let(:request) { RocketGate::Request.new(transaction) }
+  let(:base_tx) do
+    RocketGate::Transaction.new.tap do |tx|
+      tx.id                 = 'b7bb0d51-ce1a-4dd2-b0f4-61e5ff5449db'
+      tx.amount             = 1.00
+
+      tx.customer = RocketGate::Customer.new.tap do |cust|
+        cust.id             = '17da86fd-7bac-4fa0-88c1-7396b3897ac2'
+        cust.first_name     = 'John'
+        cust.last_name      = 'Test'
+        cust.street_address = '1234 Main Street'
+        cust.city           = 'Las Vegas'
+        cust.state          = 'NV'
+        cust.postal_code    = '89141'
+        cust.country        = 'US'
+        cust.email          = 'user@test.com'
+        cust.ip_address     = '216.239.116.167'
+      end
+
+      tx.credit_card = RocketGate::CreditCard.new.tap do |cc|
+        cc.number           = '4012 8888 8888 1881'
+        cc.exp_month        = '08'
+        cc.exp_year         = '2042'
+        cc.cvv              = '1111'
+      end
+    end
+  end
+
+  describe 'Test Case #1 (auth-only, then ticket for authorization by ID)' do
+    let(:transaction) { base_tx.dup }
+    before { transaction.type = RocketGate::Transaction::TYPE[:auth] }
+
+    it 'successfully authorizes, confirms, and settles a transaction' do
+      auth_response = RocketGate.send_request!(RocketGate::Request.new(transaction))
+      expect(auth_response).to be_success
+      expect(auth_response.authorization).not_to be_declined
+
+      confirmation_response = auth_response.confirm!
+      expect(confirmation_response).to be_success
+
+      ticket_tx = RocketGate::Transaction.new.tap do |tx|
+        tx.reference_id = auth_response.authorization.reference_id
+        tx.type = RocketGate::Transaction::TYPE[:ticket]
+      end
+
+      ticket_response = RocketGate.send_request!(RocketGate::Request.new(ticket_tx))
+      expect(ticket_response).to be_success
+      expect(ticket_response).to be_authorized
+      expect(ticket_response.authorization).not_to be_declined
+      expect(ticket_response.authorization.approved_amount).to eq 1.0
+      expect(ticket_response.authorization.approved_currency).to eq 'USD'
+      expect(ticket_response.authorization.card_last_four).to eq '1881'
+      expect(ticket_response.authorization.card_expiration).to eq '0842'
+      expect(ticket_response.authorization.card_hash).to eq '3RPN+a+d07r0bOlq7NcWPKvzgcyyHmPxXw+hCxxmP6k='
+      expect(ticket_response.authorization.reference_id).not_to be_nil
+    end
+  end
+
+  describe 'Test Case #2 (make sale, then void sale by ID)' do
+    let(:transaction) { base_tx.dup }
+    before { transaction.type = RocketGate::Transaction::TYPE[:purchase] }
+
+    it 'successfully charges and voids a transaction' do
+      sale_response = RocketGate.send_request!(RocketGate::Request.new(transaction))
+      expect(sale_response).to be_success
+      expect(sale_response.authorization).not_to be_declined
+
+      confirmation_response = sale_response.confirm!
+      expect(confirmation_response).to be_success
+
+      void_tx = RocketGate::Transaction.new.tap do |tx|
+        tx.reference_id = sale_response.authorization.reference_id
+        tx.type = RocketGate::Transaction::TYPE[:void]
+      end
+      void_response = RocketGate.send_request!(RocketGate::Request.new(void_tx))
+
+      expect(void_response).to be_success
+      expect(void_response).to be_authorized
+      expect(void_response.authorization).not_to be_declined
+      expect(void_response.authorization.approved_amount).to eq 1.0
+      expect(void_response.authorization.approved_currency).to eq 'USD'
+      expect(void_response.authorization.card_last_four).to eq '1881'
+      expect(void_response.authorization.card_expiration).to eq '0842'
+      expect(void_response.authorization.card_hash).to eq '3RPN+a+d07r0bOlq7NcWPKvzgcyyHmPxXw+hCxxmP6k='
+    end
+  end
+
+  describe 'Test Case #3 (failed AVS check, response of N)' do
+    let(:transaction) { base_tx.dup }
+    before { transaction.customer.postal_code = '00008' }
+
+    it 'returns an unsuccessful response' do
+      response = RocketGate.send_request!(RocketGate::Request.new(transaction))
+      expect(response).not_to be_success
+      expect(response.authorization).to be_declined
+      expect(response.authorization.avs_ok?).to be false
+    end
+  end
+
+  describe 'Test Case #4 (failed CVV check, response of N)' do
+    let(:transaction) { base_tx.dup }
+    before { transaction.credit_card.cvv = '0001' }
+
+    it 'returns an unsuccessful response' do
+      response = RocketGate.send_request!(RocketGate::Request.new(transaction))
+      expect(response).not_to be_success
+      expect(response.authorization).to be_declined
+      expect(response.authorization.cvv_ok?).to be false
+    end
+  end
+
+  describe 'Test Case #5 (declined, card over limit)' do
+    let(:transaction) { base_tx.dup }
+    before { transaction.amount = 0.02 }
+
+    it 'returns an unsuccessful response' do
+      response = RocketGate.send_request!(RocketGate::Request.new(transaction))
+      expect(response).not_to be_success
+      expect(response.authorization).to be_declined
+      expect(response.authorization.reason_code).to eq :declined_over_limit
+    end
+  end
+end