ruby_psigate 0.7

data/test/unit/account_test.rb

@@ -0,0 +1,388 @@
+require 'test_helper'
+
+module RubyPsigate
+
+  # This class needs to perform a few functions:
+  # 1) Retrieve summary level information (account, charge, invoice, template, email report)
+  # 2) Perform body level functions
+  # 3) Perform detail level functions
+  class AccountTest < Test::Unit::TestCase
+    
+    def setup
+      @account = Account.new
+    end
+    
+    should "have a getter/setter for account_id" do
+      assert @account.respond_to?(:account_id)
+      assert @account.respond_to?(:account_id=)
+    end
+    
+    context "actions" do
+      should "have a getter/setter" do
+        assert @account.respond_to?(:action)
+        assert @account.respond_to?(:action=)
+      end
+      
+      should "set action to :register, returns AMA01" do
+        @account.action = { :account => :register }
+        assert_equal "AMA01", @account.action
+      end
+      
+      should "return :account_register when looking up with AMA01" do
+        response = Account.action_reverse_lookup("AMA01")
+        assert_equal :account_register, response
+      end
+    end
+    
+    context "credit card interface" do
+      setup do
+        @account = Order.new
+      end
+      
+      should "accept a CreditCard object" do
+        assert @account.respond_to?(:cc=)
+      end
+      
+      should "not raise error when setting credit card object" do
+        @cc = mock()
+        @cc.expects(:is_a?).with(RubyPsigate::CreditCard).returns(true)
+        assert_nothing_raised do
+          @account.cc = @cc
+        end
+      end
+      
+      should "raise error if credit card object is not RubyPsigate::CreditCard" do
+        assert_raises(InvalidCreditCard) do
+          @cc = mock()
+          @cc.expects(:is_a?).with(RubyPsigate::CreditCard).returns(false)
+          @account.cc = @cc
+        end
+      end      
+    end
+    
+    context "address" do
+      should "have a getter/setter" do
+        assert @account.respond_to?(:address)
+        assert @account.respond_to?(:address=)
+      end
+      
+      should "raise error if address is not an Address object" do
+        assert_raises(InvalidAddress) do
+          @account.address = "my address"
+        end
+      end
+    end
+    
+    should "have a email getter/setter" do
+      assert @account.respond_to?(:email)
+      assert @account.respond_to?(:email=)
+    end
+    
+    should "have a comments getter/setter" do
+      assert @account.respond_to?(:comments)
+      assert @account.respond_to?(:comments=)
+    end
+    
+    should "have a serial number getter/setter (used for payment method identifier)" do
+      assert @account.respond_to?(:serial_no)
+      assert @account.respond_to?(:serial_no=)
+    end
+    
+    should "return a hash for :register" do
+      @expectation = {
+        :Action => "AMA01",
+        :Account => {
+          :AccountID => nil
+        }
+      }
+      @expectation[:Account].merge!(valid_address_hash)
+      @expectation[:Account][:CardInfo] = valid_credit_card_hash(:card_info)
+
+      @account.action = { :account => :register }
+      @account.account_id = nil
+      @account.address = valid_address
+      @account.cc = valid_credit_card
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+  
+    should "return a hash for :update" do
+      @expectation = {
+        :Action => "AMA02",
+        :Condition => {
+          :AccountID => "1234567890"
+        },
+        :Update => {}
+      }
+      @expectation[:Update].merge!(valid_address_hash)
+      @expectation[:Update].merge!(:Email => "bob@gmail.com")
+      @expectation[:Update].merge!(:Comments => "Some comment here")
+      
+      @account.action = { :account => :update }
+      @account.account_id = "1234567890"
+      @account.address = valid_address
+      @account.email = "bob@gmail.com"
+      @account.comments = "Some comment here"
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for retrieving account details" do
+      @expectation = {
+        :Action => "AMA05",
+        :Condition => {
+          :AccountID => "1234567890"
+        }
+      }
+      
+      @account.action = { :account => :details }
+      @account.account_id = "1234567890"
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for enabling account" do
+      @expectation = {
+        :Action => "AMA08",
+        :Condition => {
+          :AccountID => "1234567890"
+        }
+      }
+      
+      @account.action = { :account => :enable }
+      @account.account_id = "1234567890"
+      assert_equal @expectation, @account.to_hash(@account.action)      
+    end
+  
+    should "return a hash for disabling account" do
+      @expectation = {
+        :Action => "AMA09",
+        :Condition => {
+          :AccountID => "1234567890"
+        }
+      }
+      
+      @account.action = { :account => :disable }
+      @account.account_id = "1234567890"
+      assert_equal @expectation, @account.to_hash(@account.action)      
+    end
+    
+    should "return a hash for adding a new credit card" do
+      @expectation = {
+        :Action => "AMA11",
+        :Account => {
+          :AccountID => "1234567890",
+          :CardInfo => {}
+        }
+      }
+      @expectation[:Account][:CardInfo].merge!(valid_credit_card_hash(:card_info))
+      
+      @account.action = { :credit_card => :add }
+      @account.account_id = "1234567890"
+      @account.cc = valid_credit_card
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for deleting a credit card" do
+      @expectation = {
+        :Action => "AMA14",
+        :Condition => {
+          :AccountID => "1234567890",
+          :SerialNo => "99"
+        }
+      }
+      
+      @account.action = { :credit_card => :delete }
+      @account.account_id = "1234567890"
+      @account.serial_no = "99"
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for enabling a credit card" do
+      @expectation = {
+        :Action => "AMA18",
+        :Condition => {
+          :AccountID => "1234567890",
+          :SerialNo => "99"
+        }
+      }
+      
+      @account.action = { :credit_card => :enable }
+      @account.account_id = "1234567890"
+      @account.serial_no = "99"
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for disabling a credit card" do
+      @expectation = {
+        :Action => "AMA19",
+        :Condition => {
+          :AccountID => "1234567890",
+          :SerialNo => "99"
+        }
+      }
+      
+      @account.action = { :credit_card => :disable }
+      @account.account_id = "1234567890"
+      @account.serial_no = "99"
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+  
+    should "return a hash for retrieval of charge summary" do
+      @expectation = {
+        :Action => "RBC00",
+        :Condition => {
+          :AccountID => "1234567890",
+          :StoreID => "MYSTORE"
+        }
+      }
+      @expectation[:Condition].merge!(valid_recurring_charge_hash)
+
+      @account.action = { :charges => :summary }
+      @account.rbcharge = valid_recurring_charge
+      @account.account_id = "1234567890"
+      @account.store_id = "MYSTORE"
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for registering a new charge" do
+      @expectation = {
+        :Action => "RBC01",
+        :Charge => {
+          :AccountID => "1234567890",
+          :SerialNo => "99",
+          :RBCID => "9999999999",
+          :RBName => "Charge123",
+          :Interval => "M",
+          :RBTrigger => "25",
+          :StartTime => "2010.08.01",
+          :EndTime => "2015.12.31",
+          :ItemInfo => [{
+            :ProductID => "Newspaper",
+            :Description => "Toronto Star",
+            :Quantity => "1",
+            :Price => "25.00",
+            :Tax1 => "2.00",
+            :Tax2 => "1.25"
+          }, {
+            :ProductID => "Newspaper",
+            :Description => "Toronto Star",
+            :Quantity => "1",
+            :Price => "25.00",
+            :Tax1 => "2.00",
+            :Tax2 => "1.25"
+          }]
+        }
+      }
+      
+      @account.action = { :charges => :add }
+      @account.account_id = "1234567890"
+      @account.serial_no = "99"
+      @recurring_charge = valid_recurring_charge
+      @recurring_charge.status = nil
+      @recurring_charge.processtype = nil
+      2.times { @recurring_charge << valid_recurring_item }
+      @account.rbcharge = @recurring_charge
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for updating a charge" do
+      @expectation = {
+        :Action => "RBC02",
+        :Condition => { :RBCID => "9999999999" },
+        :Update => { :RBTrigger => "25" }
+      }
+      
+      @account.action = { :charges => :update }
+      @account.rbcharge = RecurringCharge.new(:rbcid => "9999999999", :rbtrigger => "25")
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+  
+    should "return a hash for deleting a charge" do
+      @expectation = {
+        :Action => "RBC04",
+        :Condition => { :RBCID => "9999999999" }
+      }
+      
+      @account.action = { :charges => :delete }
+      @account.rbcharge = RecurringCharge.new(:rbcid => "9999999999")
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for retrieving a charge" do
+      @expectation = {
+        :Action => "RBC05",
+        :Condition => { :RBCID => "9999999999" }
+      }
+      
+      @account.action = { :charges => :details }
+      @account.rbcharge = RecurringCharge.new(:rbcid => "9999999999")
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for enabling charges" do
+      @expectation = {
+        :Action => "RBC08",
+        :Condition => { :RBCID => "9999999999" }
+      }
+      
+      @account.action = { :charges => :enable }
+      @account.rbcharge = RecurringCharge.new(:rbcid => "9999999999")
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for disabling charges" do
+      @expectation = {
+        :Action => "RBC09",
+        :Condition => { :RBCID => "9999999999" }
+      }
+      
+      @account.action = { :charges => :disable }
+      @account.rbcharge = RecurringCharge.new(:rbcid => "9999999999")
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+    
+    should "return a hash for immediate charge" do
+      @expectation = {
+        :Action => "RBC99",
+        :Charge => {
+          :AccountID => "1234567890",
+          :SerialNo => "1",
+          :RBName => "Immediate Payment",
+          :ItemInfo => [
+            {
+              :ProductID => "Newspaper",
+              :Description => "Toronto Star",
+              :Quantity => "1",
+              :Price => "25.00",
+              :Tax1 => "2.00",
+              :Tax2 => "1.25"
+            }
+          ]
+        }
+      }
+      
+      @account.action = { :charges => :immediate }
+      @account.account_id = "1234567890"
+      @account.serial_no = "1"
+
+      @recurring_charge = RecurringCharge.new(:rbname => "Immediate Payment")
+      @recurring_charge << valid_recurring_item
+      
+      @account.rbcharge = @recurring_charge
+      
+      assert_equal @expectation, @account.to_hash(@account.action)
+    end
+  
+  end
+end

data/test/unit/address_test.rb

@@ -0,0 +1,99 @@
+require 'test_helper'
+
+module RubyPsigate
+  class AddressTest < Test::Unit::TestCase
+    
+    def setup
+      @address = Address.new
+    end
+    
+    %w( firstname lastname line1 line2 city state province country zipcode postalcode telephone fax company ).each do |field|
+      should "respond to #{field}" do
+        assert @address.respond_to?(field.downcase.to_sym)
+        setter = field.downcase + "="
+        assert @address.respond_to?(setter.to_sym)
+      end
+    end
+    
+    should "when setting :state, also sets :province" do
+      @address.state = "Some value"
+      assert_equal @address.province, @address.state
+    end
+    
+    should "when setting :province, also sets :state" do
+      @address.province = "Some value"
+      assert_equal @address.state, @address.province
+    end
+    
+    should "when setting :zipcode, also sets :postalcode" do
+      @address.zipcode = "Some value"
+      assert_equal @address.postalcode, @address.zipcode
+    end
+    
+    should "when setting :postalcode, also sets :zipcode" do
+      @address.postalcode = "Some value"
+      assert_equal @address.zipcode, @address.postalcode
+    end
+    
+    should "have a method #name that combines firstname and lastname" do
+      @address.firstname  = "Bob"
+      @address.lastname   = "Parsons"
+      assert_equal "Bob Parsons", @address.name
+    end
+    
+    should "return firstname only" do
+      @address.firstname = "Bob"
+      assert_equal "Bob", @address.name
+    end
+    
+    should "return lastname only" do
+      @address.lastname = "Parsons"
+      assert_equal "Parsons", @address.name
+    end
+    
+    should "have an alias address1 to line1" do
+      @address.line1 = "Some address"
+      assert_equal "Some address", @address.address1
+    end
+    
+    should "have an alias address2 to line2" do
+      @address.line2 = "Some address"
+      assert_equal "Some address", @address.address2
+    end
+    
+    should "return a hash of billing address attributes" do
+      @address = valid_address
+      @expectation = {
+        :Bname        => "Bob Parsons",
+        :Bcompany     => "Bob Parson's Co.",
+        :Baddress1    => "1234 West Street",
+        :Baddress2    => "Apt 100",
+        :Bcity        => "Toronto",
+        :Bprovince    => "Ontario",
+        :Bcountry     => "CA",
+        :Bpostalcode  => "L3N9J2",
+        :Phone        => "416-333-3333",
+        :Fax          => "416-322-2222"
+      }
+      
+      assert_equal @expectation, @address.to_hash(:billing)
+    end
+    
+    should "return a hash of shipping address attributes" do
+      @address = valid_address
+      @expectation = {
+        :Sname        => "Bob Parsons",
+        :Scompany     => "Bob Parson's Co.",
+        :Saddress1    => "1234 West Street",
+        :Saddress2    => "Apt 100",
+        :Scity        => "Toronto",
+        :Sprovince    => "Ontario",
+        :Scountry     => "CA",
+        :Spostalcode  => "L3N9J2"
+      }
+      
+      assert_equal @expectation, @address.to_hash(:shipping)
+    end
+    
+  end
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+
+module RubyPsigate
+  class ConnectionTest < Test::Unit::TestCase
+    
+    def setup
+      @ok = stub(:code => 200, :message => 'OK', :body => 'success')
+      @internal_server_error = stub(:code => 500, :message => 'Internal Server Error', :body => 'failure')
+      
+      @endpoint = "https://dev.psigate.com:7989/Messenger/XMLMessenger"
+      @connection = RubyPsigate::Connection.new(@endpoint)      
+    end
+    
+    context "uri" do
+      should "be parsed from endpoint" do
+        assert_equal URI.parse(@endpoint), @connection.endpoint
+      end
+      
+      should "connection parser should also accept uri directly" do
+        endpoint = URI.parse(@endpoint)
+        connection = RubyPsigate::Connection.new(endpoint)
+        assert_equal endpoint, connection.endpoint
+      end
+
+      should "raise uri error" do
+        assert_raises URI::InvalidURIError do
+          RubyPsigate::Connection.new("hello world")
+        end
+      end
+    end
+    
+    context "making requests" do
+      should "be successful when making a POST request" do
+        Net::HTTP.any_instance.expects(:post).with('/Messenger/XMLMessenger', 'data').returns(@ok)
+        response = @connection.post('data')
+        assert_equal 'success', response
+      end
+      
+      should "raise error when encounter internal server error" do
+        Net::HTTP.any_instance.stubs(:post).returns(@internal_server_error)
+        assert_raises(RubyPsigate::ResponseError) do
+          @connection.post('')
+        end
+      end
+    end
+    
+    context "timeouts" do
+      should "have a read timeout" do
+        assert_equal RubyPsigate::Connection::READ_TIMEOUT, @connection.read_timeout
+      end
+      
+      should "change the read timeout" do
+        @connection.read_timeout = 33
+        assert_equal @connection.read_timeout, 33
+      end
+      
+      should "have an open timeout" do
+        assert_equal RubyPsigate::Connection::OPEN_TIMEOUT, @connection.open_timeout
+      end
+      
+      should "change the open timeout" do
+        @connection.open_timeout = 5
+        assert_equal @connection.open_timeout, 5
+      end
+      
+      should "raise error on Timeout::Error" do
+        Net::HTTP.any_instance.expects(:post).raises(Timeout::Error)
+        
+        @connection.retry_safe = false
+        
+        assert_raises(RubyPsigate::ConnectionError) do
+          @connection.post('')
+        end
+      end
+      
+      should "raise error on Timeout::Error" do
+        Net::HTTP.any_instance.expects(:post).raises(Timeout::Error)
+        
+        @connection.retry_safe = false
+        
+        assert_raises(RubyPsigate::ConnectionError) do
+          @connection.post('')
+        end
+      end
+      
+      should "raise error on Errno::ETIMEDOUT" do
+        Net::HTTP.any_instance.expects(:post).raises(Errno::ETIMEDOUT)
+        
+        @connection.retry_safe = false
+        
+        assert_raises(RubyPsigate::ConnectionError) do
+          @connection.post('')
+        end
+      end
+    end
+    
+    context "peer verification" do
+      should "have a default value" do
+        assert_equal RubyPsigate::Connection::VERIFY_PEER, @connection.verify_peer
+      end
+      
+      should "be overridden" do
+        @connection.verify_peer = false
+        assert_equal @connection.verify_peer, false
+      end
+      
+      should "raise error if cacert.pem (verification file) is missing" do
+        File.expects(:exists?).returns(false)
+        assert_raises(RubyPsigate::CertVerificationFileMissingError) do
+          @connection.post('')
+        end
+      end
+    end
+    
+    context "failures" do
+      should "raise error when met with EOFError" do
+        Net::HTTP.any_instance.expects(:post).raises(EOFError)
+        
+        @connection.retry_safe = false
+        
+        assert_raises(RubyPsigate::ConnectionError) do
+          @connection.post('')
+        end
+      end
+      
+      should "retry after recoverable exception" do
+        Net::HTTP.any_instance.expects(:post).times(2).raises(Errno::ECONNREFUSED).then.returns(@ok)
+        
+        assert_nothing_raised do
+          @connection.post('')
+        end
+      end
+      
+      should "raise error when retry limit is reached" do
+        Net::HTTP.any_instance.expects(:post).times(RubyPsigate::Connection::MAX_RETRIES).raises(Errno::ECONNREFUSED)
+        assert_raises(RubyPsigate::ConnectionError) do
+          @connection.post('')
+        end
+      end
+      
+      should "raise error after a mixture of errors raised" do
+        Net::HTTP.any_instance.expects(:post).times(3).raises(Errno::ECONNRESET).
+                                                       raises(Errno::ECONNREFUSED).
+                                                       raises(EOFError)
+                                                       
+        assert_raises(RubyPsigate::ConnectionError) do
+          @connection.post('')
+        end
+      end
+    end
+    
+  end
+end