exact4r 0.5.2 → 0.6

data/lib/ews/transporter.rb

@@ -0,0 +1,143 @@
+require 'net/https'
+
+module EWS # :nodoc:
+
+  # A Transporter is responsible for communicating with the E-xact Web Service in
+  # whichever dialect is chosen by the user. The available options are:
+  #   :json     REST with JSON payload
+  #   :rest     REST with XML payload (default)
+  #   :soap     SOAP
+  #
+  # The Transporter will connect to the service, using SSL if required, and will
+  # encode Reqests to send to the service, and decode Responses received from the
+  # service.
+  #
+  # Once configured to connect to a particular service, it can be used repeatedly
+  # to send as many transactions as required.
+  class Transporter
+
+    # Initialize a Transporter.
+    #
+    # You can specify the URL you would like the Transporter to connect to, although it defaults
+    # to https://api.e-xact.com, the location of our transaction processing web service.
+    #
+    # You can also specify a hash of options as follows:
+    #   :server_cert      the path to the server's certificate
+    #   :issuer_cert      the path to the certificate of the issuer of the server certificate
+    #   :transport_type   the transport_type for this transporter (defaults to :rest)
+    #
+    # The default certificates are those required to connect to https://api.e-xact.com and the
+    # default <tt>transport_type</tt> is <tt>:rest</tt>. The default <tt>transport_type</tt> can be overridden on a per-transaction
+    # basis, if you choose to do so, by specifying it as a parameter to the <tt>submit</tt> method.
+    def initialize(url = "https://api.e-xact.com/", options = {})
+      @url = URI.parse(url.gsub(/\/$/,''))
+      base = File.dirname(__FILE__)
+      @server_cert = options[:server_cert] || base+"/../../certs/exact.cer"
+      @issuer_cert = options[:issuer_cert] || base+"/../../certs/equifax_ca.cer"
+      @transport_type = options[:transport_type] || :json
+    end
+
+    # Submit a transaction request to the server
+    #
+    # <tt>transaction</tt>::  the Request object to encode for transmission to the server
+    # <tt>transport_type</tt>::  (optional) the transport type to use for this transaction only. If it is not specified, the Transporter's transport type will be used
+    def submit(transaction, transport_type = nil)
+      raise "Request not supplied" if transaction.nil?
+      return false unless transaction.valid?
+
+      transport_type ||= @transport_type
+
+      raise "Transport type #{transport_type} is not supported" unless @@transport_types.include? transport_type
+
+      transport_details = @@transport_types[transport_type]
+      
+      request = build_http_request(transaction, transport_type, transport_details[:suffix])
+      request.basic_auth(transaction.gateway_id, transaction.password)
+      request.add_field "Accept", transport_details[:content_type]
+      request.add_field "User-Agent", "Ruby"
+      request.add_field "Content-type", "#{transport_details[:content_type]}; charset=UTF-8"
+
+      response = get_connection.request(request)
+
+      case response
+      when Net::HTTPSuccess then EWS::Transaction::Mapping.send "#{transport_type}_to_response", response.body
+      else
+        r = ::EWS::Transaction::Response.new
+        if(transport_type == :soap)
+          # we may have a SOAP Fault
+          r = EWS::Transaction::Mapping.send "#{transport_type}_to_response", response.body
+        end
+
+        # SOAP Fault may already have populated the error_number etc.
+        unless r.error_number
+          # populate the error number and description
+          r.error_number = response.code.to_i
+          r.error_description = response.message
+        end
+        
+        r
+      end
+
+    end
+
+private
+
+    def build_http_request(transaction, transport_type, request_suffix)
+      req = nil
+      if !transaction.is_find_transaction? or transport_type == :soap
+        req = Net::HTTP::Post.new(@url.path + "/transaction.#{request_suffix}")
+        if transport_type == :soap
+          # add the SOAPAction header
+          soapaction = (transaction.is_find_transaction?) ? "TransactionInfo" : "SendAndCommit"
+          req.add_field "soapaction", "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/#{soapaction}"
+        end
+        req.body = EWS::Transaction::Mapping.send "request_to_#{transport_type.to_s}", transaction
+      else
+        req = Net::HTTP::Get.new(@url.path + "/transaction/#{transaction.transaction_tag}.#{request_suffix}")
+      end
+      req
+    end
+    
+    def get_connection
+      # re-use the connection if it's available
+      return @connection unless @connection.nil?
+      
+      @connection = Net::HTTP.new(@url.host, @url.port)
+      @connection.set_debug_output $stdout if $DEBUG
+      if @url.scheme == 'https'
+        @connection.use_ssl = true
+        @connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        @connection.ca_file = @issuer_cert
+        @connection.verify_callback = method(:validate_certificate)
+      end
+      @connection
+    end
+
+    # from OpenSSL doco:
+    # peer cert is always at chain[0], root CA at chain[n-1]
+    # OpenSSL validates signatures, and issuer attributes at each step in the chain; is_ok reflects the status of these checks
+    def validate_certificate(is_ok, ctx)
+      # if OpenSSL has flagged an issue, then fail
+      return false unless is_ok
+      
+      peer_cert = ctx.chain[0].to_pem
+      current_cert = ctx.current_cert
+      
+      # we're not interested in additional checking of the CA certs
+      return is_ok unless peer_cert == current_cert.to_pem
+
+      # check that the peer_cert is the same as the one we expect for this URL
+      contents = File.open(@server_cert).read
+      cert = OpenSSL::X509::Certificate.new(contents)
+      return OpenSSL::Digest::SHA1.new(current_cert.to_der) == OpenSSL::Digest::SHA1.new(cert.to_der)
+    end
+
+    # what transport types we support, and their corresponding suffixes
+    @@transport_types = {
+      :rest => {:suffix => "xml", :content_type => "application/xml"},
+      :json => {:suffix => "json", :content_type => "application/json"},
+      :soap => {:suffix => "xmlsoap", :content_type => "application/xml"}
+    }
+
+  end
+end

data/lib/exact4r.rb

@@ -3,4 +3,7 @@ require 'rubygems'
 require 'ews/transaction/mapping'
 require 'ews/transaction/request'
 require 'ews/transaction/response'
-require 'ews/transaction/transporter'
+require 'ews/transaction/validator'
+require 'ews/transporter'
+
+require 'ews/transaction/fake_response'

data/spec/donncha_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "Something" do
+  it "should support soap" do
+    txn = basic_new_transaction()
+    puts txn.errors.inspect unless txn.valid?
+    
+    transporter = EWS::Transporter.new(LOCATION)
+    resp = transporter.submit(txn, :json)
+
+    puts resp.ctr
+  end
+end

data/spec/mapping_spec.rb

@@ -11,7 +11,7 @@ describe "Mapping TO formats" do
     res["amount"].should == "10.13"
     res["cardholder_name"].should == "Simon Brown"
     res["cc_number"].should == "4111111111111111"
-    res["cc_expiry"].should == "1005"
+    res["cc_expiry"].should == "1012"
   end
 
   it "should generate a REST payload" do
@@ -24,7 +24,7 @@ describe "Mapping TO formats" do
     REXML::XPath.first(txn, "Card_Number").text.should == "4111111111111111"
     REXML::XPath.first(txn, "CardHoldersName").text.should == "Simon Brown"
     REXML::XPath.first(txn, "Transaction_Type").text.should == "00"
-    REXML::XPath.first(txn, "Expiry_Date").text.should == "1005"
+    REXML::XPath.first(txn, "Expiry_Date").text.should == "1012"
     REXML::XPath.first(txn, "DollarAmount").text.should == "10.13"
   end
 
@@ -38,7 +38,7 @@ describe "Mapping TO formats" do
     REXML::XPath.first(txn, "Card_Number").text.should == "4111111111111111"
     REXML::XPath.first(txn, "CardHoldersName").text.should == "Simon Brown"
     REXML::XPath.first(txn, "Transaction_Type").text.should == "00"
-    REXML::XPath.first(txn, "Expiry_Date").text.should == "1005"
+    REXML::XPath.first(txn, "Expiry_Date").text.should == "1012"
     REXML::XPath.first(txn, "DollarAmount").text.should == "10.13"
   end  
 end
@@ -80,6 +80,47 @@ PAYLOAD
       r.transaction_type.should == "00"
     end
 
-    it "should parse a SOAP payload"
+    it "should parse a SOAP Fault payload with <details>" do
+      payload = <<PAYLOAD
+      <?xml version="1.0" encoding="utf-8"?>
+      <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+        <soap:Body>
+          <soap:Fault>
+            <faultcode>soap:Server</faultcode>
+            <faultstring>System.Web.Services.Protocols.SoapException: Setup Error at rpc-enc.Service.SendAndCommit(Transaction Transaction) in C:\Documents and Settings\defaultuser\VSWebCache\secure2.exact.com\vplug-in\transaction\rpc-enc\Service.asmx.vb:line 99</faultstring>
+            <faultactor>http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/Service.asmx</faultactor>
+            <detail>
+              <error number="500" description="Internal Server Error. An unknown error occurred." xmlns="http://secure2.e-xact.com/vplug-in/transaction/rpc-enc"/>
+            </detail>
+          </soap:Fault>
+        </soap:Body>
+      </soap:Envelope>
+PAYLOAD
+
+      r = EWS::Transaction::Mapping.soap_to_response(payload)
+
+      r.error_number.should == 500
+      r.error_description.should == "Internal Server Error. An unknown error occurred."
+      r.should_not be_approved
+    end
 
+    it "should throw an exception when a SOAP Fault contains no details" do
+      payload = <<PAYLOAD
+      <?xml version="1.0" encoding="utf-8"?>
+      <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+        <soap:Body>
+          <soap:Fault>
+            <faultcode>soap:Client</faultcode>
+            <faultstring>Server was unable to read request. --&gt; There is an error in XML document (1, 406). --&gt; &lt;SendAndCommit xmlns='http://secure2.exact.com/vplug-in/transaction/rpc-enc/'&gt; was not expected.</faultstring>
+            <detail />
+          </soap:Fault>
+        </soap:Body> 
+      </soap:Envelope>
+PAYLOAD
+
+      lambda {
+        EWS::Transaction::Mapping.soap_to_response(payload)
+      }.should raise_error
+    end
+    
 end

data/spec/request_spec.rb

@@ -12,56 +12,36 @@ describe "Request" do
     r.amount.should == "10.13"
     r.cardholder_name.should == "Simon Brown"
     r.cc_number.should == "4111111111111111"
-    r.cc_expiry.should == "1005"
+    r.cc_expiry.should == "1012"
   end
   
-  it "should require gateway_id and password " do
-    EWS::Transaction::Request.new(basic_params).should be_valid
+  it "should raise an error with invalid tranasction_type" do
+    lambda {
+      EWS::Transaction::Request.new(basic_params(:transaction_type => "00"))
+    }.should_not raise_error
+    
+    lambda {
+      EWS::Transaction::Request.new(basic_params(:transaction_type => :purchase))
+    }.should_not raise_error
 
-    EWS::Transaction::Request.new(basic_params(:gateway_id => nil)).should_not be_valid
-    EWS::Transaction::Request.new(basic_params(:gateway_id => "")).should_not be_valid
+    lambda {
+      EWS::Transaction::Request.new(basic_params(:transaction_type => nil))      
+    }.should raise_error
 
-    EWS::Transaction::Request.new(basic_params(:password => nil)).should_not be_valid
-    EWS::Transaction::Request.new(basic_params(:password => "")).should_not be_valid
-  end
-  
-  it "should validate amount, cc_number and cc_expiry" do
-    # validation: amounts
-    [:amount, :surcharge_amount, :tax1_amount, :tax2_amount].each do |amount_attr|
-      EWS::Transaction::Request.new(basic_params(amount_attr => "10.13")).should be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => "10.")).should be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => "0.13")).should be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => 10.13)).should be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => 0.13)).should be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => 10)).should be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => "10.1s3")).should_not be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => "1s0.13")).should_not be_valid
-      EWS::Transaction::Request.new(basic_params(amount_attr => "dopey")).should_not be_valid
-    end
-
-    # validation: card number
-    EWS::Transaction::Request.new(basic_params(:cc_number => "4111111111111111")).should be_valid
-    EWS::Transaction::Request.new(basic_params(:cc_number => "4111111111111112")).should_not be_valid
-    
-    # validation: card expiry (should be in YYMM format)
-    EWS::Transaction::Request.new(basic_params(:cc_expiry => "1009")).should be_valid
-    EWS::Transaction::Request.new(basic_params(:cc_expiry => "0708")).should_not be_valid
-  end
-  
-  it "should be valid when symbol or value supplied for transaction_type" do
-    EWS::Transaction::Request.new(basic_params(:transaction_type => "00")).should be_valid
-    EWS::Transaction::Request.new(basic_params(:transaction_type => :purchase)).should be_valid
+    lambda {
+      EWS::Transaction::Request.new(basic_params(:transaction_type => ""))
+    }.should raise_error
 
-    EWS::Transaction::Request.new(basic_params(:transaction_type => nil)).should_not be_valid
-    EWS::Transaction::Request.new(basic_params(:transaction_type => "")).should_not be_valid
-    EWS::Transaction::Request.new(basic_params(:transaction_type => "barry")).should_not be_valid
+    lambda {
+      EWS::Transaction::Request.new(basic_params(:transaction_type => "barry"))
+    }.should raise_error    
   end
 end
-
+  
 describe "Submitting New Requests" do
 
   before :all do 
-    @transporter = EWS::Transaction::Transporter.new
+    @transporter = EWS::Transporter.new(LOCATION)
   end
   
   it "should work without a specified transport_type" do
@@ -74,53 +54,100 @@ describe "Submitting New Requests" do
     resp.transaction_tag.should_not be_nil
   end
   
-  it "should support all transport types" do
-    [:json, :rest, :soap].each do |type|
-      txn = basic_new_transaction
-      resp = @transporter.submit(txn, type)
-
-      resp.exact_resp_code.should == "00"
-      resp.exact_message.should == "Transaction Normal"
-      resp.bank_message.downcase.should match(/approved/)
-      resp.transaction_tag.should_not be_nil
-    end
+  it "should support JSON" do
+    txn = basic_new_transaction
+    resp = @transporter.submit(txn, :json)
+
+    resp.exact_resp_code.should == "00"
+    resp.exact_message.should == "Transaction Normal"
+    resp.bank_message.downcase.should match(/approved/)
+    resp.transaction_tag.should_not be_nil
   end
 
+  it "should support REST" do
+    txn = basic_new_transaction
+    resp = @transporter.submit(txn, :rest)
+
+    resp.exact_resp_code.should == "00"
+    resp.exact_message.should == "Transaction Normal"
+    resp.bank_message.downcase.should match(/approved/)
+    resp.transaction_tag.should_not be_nil
+  end
+
+  it "should support SOAP" do
+    txn = basic_new_transaction
+    resp = @transporter.submit(txn, :soap)
+
+    resp.exact_resp_code.should == "00"
+    resp.exact_message.should == "Transaction Normal"
+    resp.bank_message.downcase.should match(/approved/)
+    resp.transaction_tag.should_not be_nil
+  end
 end
 
 describe "Submitting Find Requests" do
 
   before :each do
-    @transporter = EWS::Transaction::Transporter.new
+    @transporter = EWS::Transporter.new(LOCATION)
 
-    txn = basic_new_transaction
-    @transaction_tag = @transporter.submit(txn, :json).transaction_tag
-    puts "Sleeping for replication: #{REPLICATION_TIME}s"
+    ct = basic_new_transaction
+    @transaction_tag = @transporter.submit(ct, :json).transaction_tag
+    @ft = basic_find_transaction(:transaction_tag => @transaction_tag)
+    putc '['
     sleep(REPLICATION_TIME) # need time for replication to take place on the host
-    puts "Awake"
+    putc ']'
   end
   
   it "should work without a specified transport_type" do
-    txn = basic_find_transaction(:transaction_tag => @transaction_tag)
-    resp = @transporter.submit(txn)
+    resp = @transporter.submit(@ft)
 
     resp.exact_resp_code.should == "00"
     resp.exact_message.should == "Transaction Normal"
     resp.bank_message.downcase.should match(/approved/)
-    resp.transaction_tag.should_not be_nil
+    resp.transaction_tag.should == @transaction_tag
   end
 
-  it "should support all transport types" do
-    [:json, :rest, :soap].each do |type|
-      txn = basic_find_transaction(:transaction_tag => @transaction_tag)
-      resp = @transporter.submit(txn, type)
-
-      resp.transaction_tag.should == @transaction_tag
-      resp.cc_number == "4111111111111"
-      resp.exact_resp_code.should == "00"
-      resp.exact_message.should == "Transaction Normal"
-      resp.bank_message.downcase.should match(/approved/)
-    end
+  it "should support JSON" do
+    resp = @transporter.submit(@ft, :json)
+
+    resp.cc_number == "4111111111111"
+    resp.exact_resp_code.should == "00"
+    resp.exact_message.should == "Transaction Normal"
+    resp.bank_message.downcase.should match(/approved/)
+    resp.transaction_tag.should == @transaction_tag
   end
 
+  it "should support REST" do
+    resp = @transporter.submit(@ft, :rest)
+
+    resp.cc_number == "4111111111111"
+    resp.exact_resp_code.should == "00"
+    resp.exact_message.should == "Transaction Normal"
+    resp.bank_message.downcase.should match(/approved/)
+    resp.transaction_tag.should == @transaction_tag
+  end
+
+  it "should support SOAP" do
+    resp = @transporter.submit(@ft, :soap)
+
+    resp.cc_number == "4111111111111"
+    resp.exact_resp_code.should == "00"
+    resp.exact_message.should == "Transaction Normal"
+    resp.bank_message.downcase.should match(/approved/)
+    resp.transaction_tag.should == @transaction_tag
+  end
+end
+
+describe "Fake requests" do
+  it "should stub sending" do
+    request = {:nonsense => "this is nonsense"}
+    fake_response = EWS::Transaction::FakeResponse.valid(request)
+    transporter = EWS::Transporter.new(LOCATION)
+    transporter.stubs(:submit).returns(fake_response)
+    
+    response = transporter.submit(request)
+    response.should == fake_response
+    response.should be_approved
+    response.exact_message.should == "Transaction Normal"
+  end
 end