paytrace 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f22e1455f84e910000a9d9a751021ac5e473287
-  data.tar.gz: 01202f564b24a3ba0f6188771af8170dedcba65c
+  metadata.gz: ae74bece9567072735235bb13c243480933eb2ad
+  data.tar.gz: f9a82b0cb1cecd8357cef85dc7b103de8dc52f2d
 SHA512:
-  metadata.gz: 66c923651c3dd5388ee6d692765b75c5e0f03b2e61f293ea39a35a00ffd5a897f0f0a4563a0a830c52fe6f8893f6d7da7a5d5e3f2fa267e42fa5e1df95b19dd5
-  data.tar.gz: ff35841365e29a55fe7c987e62a0ea1d8c1359598ebfb1e49c720aea0b0f0d714a18c70b2517b152b2088c11d85725debd8decd455f423d30122ecc0ed0cef96
+  metadata.gz: 4093411b2ecb7a0166affcab5ddbc0296de3d594695dabe4f6ca1a9a428ff5fe7bacd473657bd6b1624fe99c08aeac53f4afa38c9eeac1c2902df6a0b9a9df80
+  data.tar.gz: e163f38094a6034abc1739b6e12d841d7cca74c1a242bad7616831a976345252fc9a045f27085507a859e509045828154f4f2e3ce5ba079b9c34c36af5d5f7c0

data/Guardfile

@@ -0,0 +1,28 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  watch(%r{^test/(.*)_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})         { |m| "test/#{m[1]}_spec.rb" }
+  watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/README.md

@@ -77,7 +77,7 @@ end
 
 ```ruby
 # running a transaction for a customer
-transaction = Transaction.sale({amount: "1.00",customer_id: "my_customer_id"})
+transaction = Transaction.sale({amount: "1.00",customer: my_customer_id})
 
 ```
 ### Some Optional Fields

data/lib/paytrace.rb

@@ -8,6 +8,8 @@ require 'paytrace/api/fields'
 require 'paytrace/api/gateway'
 require 'paytrace/api/request'
 require 'paytrace/api/response'
+require 'paytrace/exceptions'
+require 'paytrace/recurring_transaction'
 
 module PayTrace
 end

data/lib/paytrace/address.rb

@@ -1,6 +1,6 @@
 module PayTrace
   class Address
-    attr :name, :street,:street2,:city,:state, :country,:region,:postal_code
+    attr_accessor :name, :street,:street2,:city,:state, :country,:region,:postal_code,:address_type
 
     def initialize(options={})
       @name = options[:name]
@@ -8,9 +8,23 @@ module PayTrace
       @street2 = options[:street2]
       @city = options[:city]
       @state = options[:state]
-      @region = options[:region]
       @country = options[:country]
       @postal_code = options[:postal_code ]
+      @address_type = options[:address_type] || :billing
+      @region = options[:region] if @address_type == :shipping # special case for shipping addresses
+    end
+
+    def set_request(request)
+      atype_str = address_type.to_s
+
+      request.set_param(:"#{atype_str}_name", name) if name
+      request.set_param(:"#{atype_str}_address", street) if street
+      request.set_param(:"#{atype_str}_address2", street2) if street2
+      request.set_param(:"#{atype_str}_city", city) if city
+      request.set_param(:"#{atype_str}_region", region) if region
+      request.set_param(:"#{atype_str}_state", state) if state
+      request.set_param(:"#{atype_str}_postal_code", postal_code) if postal_code
+      request.set_param(:"#{atype_str}_country", country) if country
     end
   end
 end

data/lib/paytrace/api/fields.rb

@@ -43,14 +43,27 @@ module PayTrace
         shipping_country: "SCOUNTRY",
         #customer
         customer_id: "CUSTID",
+        new_customer_id: "NEWCUSTID",
         customer_reference_id:"CUSTREF",
+        customer_password:"CUSTPSWD",
+        customer_fax:"FAX",
+        customer_phone:"PHONE",
         approval_code:"APPROVAL",
         #cash advance
         cash_advance:"CASHADVANCE",
         id_number:"PHOTOID",
         id_expiration:"IDEXP",
-        cc_last_4:"LAST4"
-
+        cc_last_4:"LAST4",
+        #bank accounts
+        account_number:"DDA",
+        routing_number:"TR",
+        #recurring transactions
+        recur_id: "RECURID",
+        recur_frequency: "FREQUENCY",
+        recur_start: "START",
+        recur_count: "TOTALCOUNT",
+        recur_receipt: "CUSTRECEIPT",
+        recur_type: "RECURTYPE"
       }
     end
   end

data/lib/paytrace/api/gateway.rb

@@ -1,19 +1,59 @@
 require 'faraday'
 require 'paytrace/api/response'
+require 'paytrace/exceptions'
 
 module PayTrace
   module API
     class Gateway
       attr_accessor :connection
+      @@debug = false
+      @@last_request = nil
+      @@last_response = nil
+      @@next_response = nil
+      @@raise_exceptions = true
 
       def initialize(connection: nil)
-        @connection = connection 
-        @connection ||= PayTrace.configuration.connection
+        @connection = connection || PayTrace.configuration.connection
+      end
+
+      def self.debug=(enable)
+        @@debug = enable
+      end 
+
+      def self.last_request
+        @@last_request
+      end
+
+      def self.last_response
+        @@last_response
+      end
+
+      def self.next_response=(next_response)
+        @@next_response = next_response
+      end
+
+      def self.raise_exceptions=(raise_exceptions)
+        @@raise_exceptions = raise_exceptions
       end
 
       def send_request(request)
-        res = @connection.post PayTrace.configuration.url, parmlist: request.to_parms_string
-        PayTrace::API::Response.new(res.body)
+        @@last_request = request.to_parms_string if @@debug
+        unless (@@debug && @@next_response)
+          res = @connection.post PayTrace.configuration.url, parmlist: request.to_parms_string
+          raw_response = res.body
+        else
+          raw_response = @@next_response
+        end
+        
+        @@last_response = raw_response
+        response = PayTrace::API::Response.new(raw_response)
+        @@next_response = nil # just to be sure
+
+        if @@raise_exceptions && response.has_errors?
+          raise PayTrace::Exceptions::ErrorResponse.new(response.get_response())
+        else
+          response
+        end
       end
     end
   end

data/lib/paytrace/api/request.rb

@@ -18,14 +18,15 @@ module PayTrace
 
       def to_parms_string()
         @params.map do |k,v|
-          "#{PayTrace::API.fields.fetch(k)}#{@value_delim}#{v}"
+          "#{PayTrace::API.fields[k]}#{@value_delim}#{v}"
         end.join(@field_delim) << "|"
       end
 
       def set_param(k, v)
-        @params[k] = v
-      end
+        raise PayTrace::Exceptions::ValidationError.new("Unknown field '#{k}'") unless PayTrace::API.fields.has_key?(k)
 
+        @params[k] = v unless v.nil?
+      end
     end
   end
 end

data/lib/paytrace/customer.rb

@@ -1,10 +1,80 @@
 module PayTrace
   class Customer
-    attr_accessor :customer_id
+    attr :id, :customer_id
 
-    def initialize(customer_id: nil)
+    CREATE_CUSTOMER = "CreateCustomer"
+    UPDATE_CUSTOMER = "UpdateCustomer"
+    DELETE_CUSTOMER = "DeleteCustomer"
+
+    def initialize(customer_id = nil)
       @customer_id = customer_id
     end
+
+    def update(params = {})
+      set_request_data(UPDATE_CUSTOMER, params)
+    end
+
+    def delete
+      request = PayTrace::API::Request.new
+      request.set_param(:method, DELETE_CUSTOMER)
+      request.set_param(:customer_id, @customer_id)
+      gateway = PayTrace::API::Gateway.new
+      gateway.send_request(request)
+    end
+
+    def self.delete(customer_id)
+      Customer.new(customer_id).delete
+    end
+
+    def self.from_cc_info(params = {})
+      customer = Customer.new(params[:customer_id])
+      customer.set_request_data(CREATE_CUSTOMER, params)
+    end
+
+    def self.from_transaction_id(params = {})
+      customer = Customer.new(params[:customer_id])
+      customer.set_request_data(CREATE_CUSTOMER, params)
+    end
+
+    def set_request_data(method, params)
+      request = PayTrace::API::Request.new
+      request.set_param(:method, method)
+      request.set_param(:customer_id, params[:customer_id])
+      request.set_param(:new_customer_id, params[:new_customer_id])
+      request.set_param(:transaction_id, params[:transaction_id])
+
+      if params[:billing_address]
+        params[:billing_address].name = nil if (method == CREATE_CUSTOMER && params[:transaction_id])
+        params[:billing_address].set_request(request)
+      end
+      params[:shipping_address].set_request(request) if params[:shipping_address]
+        
+
+      if params[:credit_card]
+        request.set_param(:card_number, params[:credit_card].card_number)
+        request.set_param(:expiration_month, params[:credit_card].expiration_month)
+        request.set_param(:expiration_year, params[:credit_card].expiration_year)
+      end
+
+      request.set_param(:email, params[:email])
+      request.set_param(:customer_phone, params[:phone]) 
+      request.set_param(:customer_fax, params[:fax]) 
+      request.set_param(:customer_password, params[:customer_password])
+      request.set_param(:account_number, params[:account_number])
+      request.set_param(:routing_number, params[:routing_number])
+      request.set_param(:discretionary_data, params[:discretionary_data])
+
+      gateway = PayTrace::API::Gateway.new
+      response = gateway.send_request(request)
+      unless response.has_errors?
+        values = response.values
+        @id = values["CUSTID"]
+        @customer_id = values["CUSTOMERID"]
+        self
+      else
+        nil
+      end
+    end
   end
 end
 

data/lib/paytrace/exceptions.rb

@@ -0,0 +1,12 @@
+module PayTrace
+  module Exceptions
+    class Base < RuntimeError
+    end
+
+    class ValidationError < Base
+    end
+
+    class ErrorResponse < Base
+    end
+  end
+end

data/lib/paytrace/recurring_transaction.rb

@@ -0,0 +1,57 @@
+require 'paytrace'
+
+module PayTrace
+  class RecurringTransaction
+    attr :id
+    CREATE_METHOD = "CreateRecur"
+    DELETE_METHOD = "DeleteRecur"
+    UPDATE_METHOD = "UpdateRecur"
+
+    def self.create(params = {})
+      set_request_data(CREATE_METHOD, params)
+    end
+
+    def self.delete(params = {})
+      request = PayTrace::API::Request.new
+      request.set_param(:method, DELETE_METHOD)
+      if params[:recur_id]
+        request.set_param(:recur_id, params[:recur_id])
+      else
+        request.set_param(:customer_id, params[:customer_id])
+      end
+
+      gateway = PayTrace::API::Gateway.new
+      parse_response(gateway.send_request(request))
+    end
+
+    def self.update(params = {})
+      set_request_data(UPDATE_METHOD, params)
+    end
+
+    def self.parse_response(response)
+      unless response.has_errors?
+        values = response.values
+        values["RECURID"]
+      end
+    end
+
+    def self.set_request_data(method, params)
+      request = PayTrace::API::Request.new
+      request.set_param(:method, method)
+
+      request.set_param(:recur_id, params[:recur_id])
+      request.set_param(:customer_id, params[:customer_id])
+      request.set_param(:recur_frequency, params[:recur_frequency])
+      request.set_param(:recur_start, params[:recur_start])
+      request.set_param(:recur_count, params[:recur_count])
+      request.set_param(:amount, params[:amount])
+      request.set_param(:transaction_type, params[:transaction_type])
+      request.set_param(:description, params[:description])
+      request.set_param(:recur_receipt, params[:recur_receipt])
+      request.set_param(:recur_type, params[:recur_type])
+
+      gateway = PayTrace::API::Gateway.new
+      parse_response(gateway.send_request(request))
+    end
+  end
+end

data/lib/paytrace/transaction.rb

@@ -52,7 +52,7 @@ module PayTrace
     def create_transaction(args,type)
       amount = args.delete(:amount)  if args[:amount]
       cc = CreditCard.new(args.delete(:credit_card)) if args[:credit_card]
-      customer = Customer.new(customer_id: args.delete(:customer_id)) if args[:customer_id]
+      customer = args.delete(:customer) if args[:customer]
 
       t = Transaction.new(amount: amount,
                           credit_card: cc,
@@ -101,18 +101,22 @@ module PayTrace
     end
 
     def set_request(request)
-      add_transaction(request)
+      add_credit_card(request, credit_card) if credit_card
+      if customer.is_a?(PayTrace::Customer)
+        request.set_param(:customer_id, customer.id)
+      elsif customer.is_a?(Fixnum)
+        request.set_param(:customer_id, customer)
+      end
+      add_transaction_info(request)
+      add_addresses(request)
+      add_optional_fields(request) if optional_fields
     end
 
     private
-    def add_transaction(request)
-      add_credit_card(request, credit_card) if credit_card
-      add_customer(request, customer) if customer
+    def add_transaction_info(request)
       request.set_param(:transaction_type, type)
       request.set_param(:method, TRANSACTION_METHOD)
       request.set_param(:amount, amount)
-      load_address(request)
-      load_misc_fields(request) if optional_fields
     end
 
     def add_credit_card(request, cc)
@@ -123,59 +127,33 @@ module PayTrace
       request.set_param(:csc, cc.csc) if cc.csc
     end
 
-
-      def load_misc_fields(request)
-        o = optional_fields
-        o.each do |k,v|
-          request.set_param(k, v)
-        end
-
-
-      end
-
-      def load_address(request)
-        add_shipping_address(request, shipping_address) if shipping_address
-        add_billing_address(request, billing_address) if billing_address
+    def add_optional_fields(request)
+      o = optional_fields
+      o.each do |k,v|
+        request.set_param(k, v)
       end
 
-      def add_customer(request, c)
-        request.set_param(:customer_id, c.customer_id)
-      end
 
-      def add_shipping_address(request, s)
-        add_address(request, "shipping",s)
-      end
-
-      def add_billing_address(request, b)
-        add_address(request, "billing",b)
-      end
-
-      def add_address(request, address_type, address)
-        request.set_param(:"#{address_type}_name", address.name) if address.name
-        request.set_param(:"#{address_type}_address", address.street) if address.street
-        request.set_param(:"#{address_type}_address2", address.street2) if address.street2
-        request.set_param(:"#{address_type}_city", address.city) if address.city
-        request.set_param(:"#{address_type}_region", address.region) if address.region
-        request.set_param(:"#{address_type}_state", address.state) if address.state
-        request.set_param(:"#{address_type}_postal_code", address.postal_code) if address.postal_code
-        request.set_param(:"#{address_type}_country", address.country) if address.country
-      end
+    end
 
+    def add_addresses(request)
+      shipping_address.set_request(request) if shipping_address
+      billing_address.set_request(request) if billing_address
+    end
 
     def include_optional(args)
       s = nil
       b = nil
 
       b = args.delete(:billing_address)  if args[:billing_address]
-      @billing_address = PayTrace::Address.new(b) if b
+      @billing_address = PayTrace::Address.new({address_type: :billing}.merge(b)) if b
       s =  args.delete(:shipping_address) if args[:shipping_address]
-      @shipping_address = PayTrace::Address.new(s) if s
+      @shipping_address = PayTrace::Address.new({address_type: :shipping}.merge(s)) if s
       if args[:address_shipping_same_as_billing]
         self.set_shipping_same_as_billing
       end
 
       @optional_fields = args
-
     end
 
 

data/lib/paytrace/version.rb

@@ -1,3 +1,3 @@
 module PayTrace
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/paytrace.gemspec

@@ -23,4 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.1"
   spec.add_development_dependency "mocha", "~> 1.0"
+  spec.add_development_dependency "guard", '~> 0'
+  spec.add_development_dependency "guard-minitest", '~> 0'
 end

data/test/paytrace/address_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '../../test_helper.rb')
+
+describe PayTrace::Address do
+  it "should accept an address type" do
+    a = PayTrace::Address.new({address_type: :shipping})
+
+    a.address_type.must_equal :shipping
+  end
+
+  it "should default to a billing address" do
+    a = PayTrace::Address.new({})
+
+    a.address_type.must_equal :billing
+  end
+
+  it "should skip blank fields" do
+    a = PayTrace::Address.new({foo: :bar, baz: :bat})
+
+    a.name.must_be_nil
+    a.street.must_be_nil
+    a.street2.must_be_nil
+    a.city.must_be_nil
+    a.state.must_be_nil
+    a.country.must_be_nil
+    a.region.must_be_nil
+    a.postal_code.must_be_nil
+
+    # special case: defaults to :billing
+    a.address_type.wont_be_nil
+  end
+
+  it "should not add arbitrary fields" do
+    a = PayTrace::Address.new({foo: :bar, baz: :bat})
+
+    a.must_respond_to(:address_type)
+    a.wont_respond_to(:foo)
+    a.wont_respond_to(:baz)
+  end
+
+
+  it "should set the request fields correctly" do
+    r = PayTrace::API::Request.new
+    a = PayTrace::Address.new({
+      name: "John Doe",
+      street: "1234 Main Street",
+      street2: "Apt. B",
+      city: "Shoreline",
+      state: "WA",
+      country: "USA",
+      region: "region??",
+      postal_code: "98133",
+      address_type: :shipping
+      })
+    a.set_request(r)
+
+    r.params[:shipping_name].must_equal "John Doe"
+    r.params[:shipping_address].must_equal "1234 Main Street"
+    r.params[:shipping_address2].must_equal "Apt. B"
+    r.params[:shipping_city].must_equal "Shoreline"
+    r.params[:shipping_state].must_equal "WA"
+    r.params[:shipping_country].must_equal "USA"
+    r.params[:shipping_region].must_equal "region??"
+    r.params[:shipping_postal_code].must_equal "98133"
+  end
+end

data/test/paytrace/api/gateway_spec.rb

@@ -2,26 +2,35 @@ require File.expand_path(File.dirname(__FILE__) + '../../../test_helper.rb')
 require 'paytrace/api/gateway'
 
 describe PayTrace::API::Gateway do
-  it "converts a request into a URL to the api specifying the user name and password from configuration" do
-    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-      stub.post ("https://paytrace.com/api/default.pay") {[ 200, {}, 'foo' ]}
-    end
+  attr :connection, :faraday
+
+  def set_mock_configuration
+    PayTrace.configure do |config|
+      stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.post ("https://paytrace.com/api/default.pay") {[ 200, {}, 'foo' ]}
+      end
+      @faraday = stubs
 
-    test = Faraday.new do |builder|
-      builder.adapter :test , stubs
+      test = Faraday.new do |builder|
+        builder.adapter :test , stubs
+      end
+      config.connection = test
+      @connection = test
     end
+  end
+
+  before do
+    set_mock_configuration()
+  end
 
+  it "converts a request into a URL to the api specifying the user name and password from configuration" do
     request = mock()
     request.stubs(:to_parms_string).returns("foo")
 
-    response = mock()
-    PayTrace::API::Response.stubs(:new).returns(response)
-
-    gateway = PayTrace::API::Gateway.new(connection: test)
+    gateway = PayTrace::API::Gateway.new(connection: connection)
     r = gateway.send_request request
 
-    stubs.verify_stubbed_calls
-    r.must_equal response
+    faraday.verify_stubbed_calls
   end
 
   it "initializes the connection based on the configuration" do
@@ -33,4 +42,69 @@ describe PayTrace::API::Gateway do
     gateway.connection.must_equal faraday_connection
   end
 
+  describe "debug mode" do
+    it "sends a mock response if directed to" do
+      PayTrace::API::Gateway.debug = true
+
+      request = PayTrace::API::Request.new
+      gateway = PayTrace::API::Gateway.new
+      canned_response = "foobar"
+      PayTrace::API::Gateway.next_response = canned_response
+
+      gateway.send_request(request)
+      PayTrace::API::Gateway.last_response.must_equal(canned_response)
+    end
+
+    it "doesn't send the same response twice" do
+      PayTrace::API::Gateway.debug = true
+
+      request = PayTrace::API::Request.new
+      gateway = PayTrace::API::Gateway.new
+      canned_response = "foobar"
+      PayTrace::API::Gateway.next_response = canned_response
+
+      gateway.send_request(request)
+      PayTrace::API::Gateway.last_response.must_equal(canned_response)
+      gateway.send_request(request)
+      PayTrace::API::Gateway.last_response.wont_equal(canned_response)
+      faraday.verify_stubbed_calls
+    end
+
+    it "does not send a mock response unless in debug mode" do
+      PayTrace::API::Gateway.debug = false
+
+      request = PayTrace::API::Request.new
+      gateway = PayTrace::API::Gateway.new
+      canned_response = "foobar"
+      PayTrace::API::Gateway.next_response = canned_response
+
+      gateway.send_request(request)
+      PayTrace::API::Gateway.last_response.wont_equal(canned_response)
+      faraday.verify_stubbed_calls
+    end
+
+    it "raises an ErrorResponse exception for errors" do
+      PayTrace::API::Gateway.debug = true # to enable mock response
+      PayTrace::API::Gateway.raise_exceptions = true
+
+      response = "ERROR~35. Please provide a valid Credit Card Number.|ERROR~43. Please provide a valid Expiration Month.|"
+      PayTrace::API::Gateway.next_response = response
+
+      request = PayTrace::API::Request.new
+      gateway = PayTrace::API::Gateway.new
+      -> { gateway.send_request(request) }.must_raise PayTrace::Exceptions::ErrorResponse
+    end
+
+    it "does not raise an ErrorResponse if raise_exceptions is false" do
+      PayTrace::API::Gateway.debug = true # to enable mock response
+      PayTrace::API::Gateway.raise_exceptions = false
+
+      response = "ERROR~35. Please provide a valid Credit Card Number.|ERROR~43. Please provide a valid Expiration Month.|"
+      PayTrace::API::Gateway.next_response = response
+
+      request = PayTrace::API::Request.new
+      gateway = PayTrace::API::Gateway.new
+      gateway.send_request(request) # if it raises an exception, the test fails; there's no "wont_raise" in minitest
+    end
+  end
 end

data/test/paytrace/api/request_spec.rb

@@ -26,7 +26,13 @@ describe PayTrace::API::Request do
 
   it "can manually set params" do
     r = PayTrace::API::Request.new
-    r.set_param(:foo, "bar")
-    r.params[:foo].must_equal "bar"
+    r.set_param(:billing_name, "Fred Jones")
+    r.params[:billing_name].must_equal "Fred Jones"
+  end
+
+  it "raises a validation exception for unknown fields" do
+    r = PayTrace::API::Request.new
+
+    -> { r.set_param(:foo, "bar") }.must_raise PayTrace::Exceptions::ValidationError
   end
 end

data/test/paytrace/customer_spec.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.dirname(__FILE__) + '../../test_helper.rb')
+
+describe PayTrace::Customer do
+  def base_url
+    "UN~#{PayTrace.configuration.user_name}|PSWD~#{PayTrace.configuration.password}|TERMS~Y|"
+  end
+
+  before do
+    PayTrace::API::Gateway.debug = true
+    PayTrace::API::Gateway.next_response = "RESPONSE~ok|CUSTOMERID~12345|CUSTID~john_doe"
+  end
+
+  describe "create customer profile" do
+    # first call path: create from credit card information
+    it "can be created from credit card information" do
+      credit_card = PayTrace::CreditCard.new({card_number: "1234123412341234", expiration_month: 12, expiration_year: 2014})
+      billing_addr = PayTrace::Address.new({name: "Foo Bar", address_type: :billing})
+
+      PayTrace::Customer.from_cc_info({customer_id: "foo_bar", credit_card: credit_card, billing_address: billing_addr})
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~CreateCustomer|CUSTID~foo_bar|BNAME~Foo Bar|CC~1234123412341234|EXPMNTH~12|EXPYR~2014|"
+    end
+
+    # second call path: create from a transaction ID
+    it "can be created from a transaction ID" do
+      PayTrace::Customer.from_transaction_id({customer_id: "foo_bar", transaction_id: 12345678})
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~CreateCustomer|CUSTID~foo_bar|TRANXID~12345678|"
+    end
+
+    # all billing address fields are accepted
+    it "accepts full billing address information" do
+      credit_card = PayTrace::CreditCard.new({card_number: "1234123412341234", expiration_month: 12, expiration_year: 2014})
+      billing_addr = PayTrace::Address.new({
+        name: "Foo Bar",
+        street: "1234 Main Street",
+        street2: "Apartment 1B",
+        city: "Shoreline",
+        state: "WA",
+        country: "USA",
+        postal_code: 98133,
+        address_type: :billing
+        })
+
+      PayTrace::Customer.from_cc_info({customer_id: "foo_bar", credit_card: credit_card, billing_address: billing_addr})
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~CreateCustomer|CUSTID~foo_bar|BNAME~Foo Bar|BADDRESS~1234 Main Street|" + 
+        "BADDRESS2~Apartment 1B|BCITY~Shoreline|BSTATE~WA|BZIP~98133|BCOUNTRY~USA|" +
+        "CC~1234123412341234|EXPMNTH~12|EXPYR~2014|"
+    end
+
+    # you can include a shipping address, too
+    it "accepts a shipping address" do
+      shipping_addr = PayTrace::Address.new({
+        name: "Foo Bar",
+        street: "1234 Main Street",
+        street2: "Apartment 1B",
+        city: "Shoreline",
+        state: "WA",
+        region: "Snohomish",
+        country: "USA",
+        postal_code: 98133,
+        address_type: :shipping
+        })
+
+      PayTrace::Customer.from_transaction_id({customer_id: "foo_bar", transaction_id: 12345678, shipping_address: shipping_addr})
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~CreateCustomer|CUSTID~foo_bar|TRANXID~12345678|SNAME~Foo Bar|SADDRESS~1234 Main Street|" + 
+        "SADDRESS2~Apartment 1B|SCITY~Shoreline|SCOUNTY~Snohomish|SSTATE~WA|SZIP~98133|SCOUNTRY~USA|"
+    end
+
+    # special case: when creating from transaction ID, the billing name is ignored (no clue why, but it's in the API)
+    it "ignores the billing address name if using a transaction id" do
+      billing_addr = PayTrace::Address.new({
+        name: "Foo Bar",
+        street: "1234 Main Street",
+        street2: "Apartment 1B",
+        city: "Shoreline",
+        state: "WA",
+        region: "region",
+        country: "USA",
+        postal_code: 98133,
+        address_type: :billing
+        })
+
+      PayTrace::Customer.from_transaction_id({customer_id: "foo_bar", transaction_id: 12345678, billing_address: billing_addr})
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~CreateCustomer|CUSTID~foo_bar|TRANXID~12345678|BADDRESS~1234 Main Street|" + 
+        "BADDRESS2~Apartment 1B|BCITY~Shoreline|BSTATE~WA|BZIP~98133|BCOUNTRY~USA|"
+    end
+
+    # there are additional fields (email, phone, discretionary data, etc.) that can be sent
+    it "accepts extra customer information" do
+      params = {
+        customer_id: "foo_bar",
+        transaction_id: 12345678,
+        email: "support@paytrace.com",
+        phone: "123-555-1212",
+        fax: "456-555-1212",
+        customer_password: "none_shall_pass",
+        account_number: 123456789,
+        routing_number: 12345678,
+        discretionary_data: "discretionary_data"
+      }
+
+      PayTrace::Customer.from_transaction_id(params)
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~CreateCustomer|CUSTID~foo_bar|TRANXID~12345678|EMAIL~support@paytrace.com|" + 
+        "PHONE~123-555-1212|FAX~456-555-1212|CUSTPSWD~none_shall_pass|DDA~123456789|TR~12345678|" +
+        "DISCRETIONARY DATA~discretionary_data|"
+    end
+  end
+
+  describe "update customer profile" do
+    it "accepts a billing address" do
+      billing_addr = PayTrace::Address.new({
+        name: "Foo Bar",
+        street: "1234 Main Street",
+        street2: "Apartment 1B",
+        city: "Shoreline",
+        state: "WA",
+        region: "region",
+        country: "USA",
+        postal_code: 98133,
+        address_type: :billing
+        })
+
+      c = PayTrace::Customer.new
+      c.update({new_customer_id: "joanie_doe", billing_address: billing_addr})
+
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~UpdateCustomer|NEWCUSTID~joanie_doe|" +
+        "BNAME~Foo Bar|BADDRESS~1234 Main Street|" + 
+        "BADDRESS2~Apartment 1B|BCITY~Shoreline|BSTATE~WA|BZIP~98133|BCOUNTRY~USA|" 
+    end
+
+    it "accepts a shipping address" do
+      shipping_addr = PayTrace::Address.new({
+        name: "Foo Bar",
+        street: "1234 Main Street",
+        street2: "Apartment 1B",
+        city: "Shoreline",
+        state: "WA",
+        region: "Snohomish",
+        country: "USA",
+        postal_code: 98133,
+        address_type: :shipping
+        })
+
+      c = PayTrace::Customer.new
+      c.update({new_customer_id: "joanie_doe", shipping_address: shipping_addr})
+
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~UpdateCustomer|NEWCUSTID~joanie_doe|" +
+        "SNAME~Foo Bar|SADDRESS~1234 Main Street|SADDRESS2~Apartment 1B|SCITY~Shoreline|SCOUNTY~Snohomish|" +
+        "SSTATE~WA|SZIP~98133|SCOUNTRY~USA|" 
+    end
+
+    it "accepts extra customer information" do
+      params = {
+        new_customer_id: "foo_bar",
+        email: "support@paytrace.com",
+        phone: "123-555-1212",
+        fax: "456-555-1212",
+        customer_password: "none_shall_pass",
+        account_number: 123456789,
+        routing_number: 12345678,
+        discretionary_data: "discretionary_data"
+      }
+
+      c = PayTrace::Customer.new
+      c.update(params)
+
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~UpdateCustomer|NEWCUSTID~foo_bar|" +
+      "EMAIL~support@paytrace.com|PHONE~123-555-1212|FAX~456-555-1212|CUSTPSWD~none_shall_pass|DDA~123456789|" +
+      "TR~12345678|DISCRETIONARY DATA~discretionary_data|"
+    end
+  end
+
+  describe "delete customer profile" do
+    it "works with an instantiated Customer object" do
+      c = PayTrace::Customer.new("foo_bar")
+       c.delete
+
+        PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~DeleteCustomer|CUSTID~foo_bar|"
+    end
+
+    it "works with a static class method" do
+      PayTrace::Customer.delete("foob_barb")
+
+      PayTrace::API::Gateway.last_request.must_equal base_url + "METHOD~DeleteCustomer|CUSTID~foob_barb|"
+    end
+  end
+end

data/test/paytrace/exceptions_spec.rb

@@ -0,0 +1,3 @@
+require File.expand_path(File.dirname(__FILE__) + '../../test_helper.rb')
+
+include PayTrace::Exceptions

data/test/paytrace/recurring_transaction_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__) + '../../test_helper.rb')
+
+describe PayTrace::RecurringTransaction do
+  def base_url(method)
+    "UN~#{PayTrace.configuration.user_name}|PSWD~#{PayTrace.configuration.password}|TERMS~Y|METHOD~#{method}|"
+  end
+  
+  describe "create recurrence" do
+    before do
+      PayTrace::API::Gateway.debug = true
+      PayTrace::API::Gateway.next_response = "RESPONSE~ok|RECURID~12345|"
+    end
+
+    it "works" do
+      params = {
+        customer_id: "foo_bar",
+        recur_frequency: "3",
+        recur_start: "4/22/2014",
+        recur_count: 999,
+        amount: 9.99,
+        transaction_type: "sale",
+        description: "Recurring transaction",
+        recur_receipt: "Y",
+        recur_type: "A"
+      }
+
+      recur_id = PayTrace::RecurringTransaction.create(params)
+      PayTrace::API::Gateway.last_request.must_equal base_url(PayTrace::RecurringTransaction::CREATE_METHOD) + 
+        "CUSTID~foo_bar|FREQUENCY~3|START~4/22/2014|TOTALCOUNT~999|AMOUNT~9.99|TRANXTYPE~sale|DESCRIPTION~Recurring transaction|CUSTRECEIPT~Y|RECURTYPE~A|"
+
+      recur_id.must_equal "12345"
+    end
+  end
+
+  describe "update recurrence" do
+    before do
+      PayTrace::API::Gateway.debug = true
+      PayTrace::API::Gateway.next_response = "RESPONSE~ok|RECURID~12345|"
+    end
+
+    it "works" do
+      params = {
+        recur_id: 12345,
+        customer_id: "foo_bar",
+        recur_frequency: "3",
+        recur_start: "4/22/2014",
+        recur_count: 999,
+        amount: 9.99,
+        transaction_type: "sale",
+        description: "Recurring transaction",
+        recur_receipt: "Y"
+      }
+
+      recur_id = PayTrace::RecurringTransaction.update(params)
+      PayTrace::API::Gateway.last_request.must_equal base_url(PayTrace::RecurringTransaction::UPDATE_METHOD) + 
+        "RECURID~12345|CUSTID~foo_bar|FREQUENCY~3|START~4/22/2014|TOTALCOUNT~999|AMOUNT~9.99|TRANXTYPE~sale|" +
+        "DESCRIPTION~Recurring transaction|CUSTRECEIPT~Y|"
+
+      recur_id.must_equal "12345"
+    end
+
+    it "accepts a recur type" do
+      params = {
+        recur_id: 12345,
+        customer_id: "foo_bar",
+        recur_frequency: "3",
+        recur_start: "4/22/2014",
+        recur_count: 999,
+        amount: 9.99,
+        transaction_type: "sale",
+        description: "Recurring transaction",
+        recur_receipt: "Y",
+        recur_type: "A"
+      }
+
+      recur_id = PayTrace::RecurringTransaction.update(params)
+      PayTrace::API::Gateway.last_request.must_equal base_url(PayTrace::RecurringTransaction::UPDATE_METHOD) + 
+        "RECURID~12345|CUSTID~foo_bar|FREQUENCY~3|START~4/22/2014|TOTALCOUNT~999|AMOUNT~9.99|TRANXTYPE~sale|" +
+        "DESCRIPTION~Recurring transaction|CUSTRECEIPT~Y|RECURTYPE~A|"
+
+      recur_id.must_equal "12345"
+    end
+  end
+
+  describe "delete recurrence" do
+    before do
+      PayTrace::API::Gateway.debug = true
+      PayTrace::API::Gateway.next_response = "RESPONSE~ok|RECURID~12345|"
+    end
+
+    it "works with a recur ID" do
+      params = {
+        recur_id: 12345
+      }
+
+      recur_id = PayTrace::RecurringTransaction.delete(params)
+      PayTrace::API::Gateway.last_request.must_equal base_url(PayTrace::RecurringTransaction::DELETE_METHOD) + 
+        "RECURID~12345|"
+      
+      recur_id.must_equal "12345"
+    end
+
+    it "works with a customer ID" do
+      params = {
+        customer_id: "foo_bar"
+      }
+
+      recur_id = PayTrace::RecurringTransaction.delete(params)
+      PayTrace::API::Gateway.last_request.must_equal base_url(PayTrace::RecurringTransaction::DELETE_METHOD) + 
+        "CUSTID~foo_bar|"
+      
+      recur_id.must_equal "12345"
+    end
+  end
+  # describe "export single recurrence"
+  # describe "bulk update recurrences"
+end

data/test/paytrace/transaction_spec.rb

@@ -52,12 +52,12 @@ describe PayTrace::Transaction do
     it "can run a transaction for a customer" do
       t = PayTrace::Transaction.sale(
           {amount: "1.00",
-           customer_id: "123456"}
+           customer: 123456}
       )
 
       t.amount.must_equal "1.00"
       t.type.must_equal PayTrace::TransactionTypes::SALE
-      t.customer.customer_id.must_equal "123456"
+      t.customer.must_equal 123456
       t.credit_card.must_be_nil
       t.response.must_equal @response
 
@@ -215,14 +215,14 @@ describe PayTrace::Transaction do
 
   it "can use a customer id for processing the transaction" do
     t = PayTrace::Transaction.new({amount: "12.34",
-                                    customer: PayTrace::Customer.new(customer_id: "1234"),
+                                    customer: 1234,
                                     type: PayTrace::TransactionTypes::SALE
                                     }
                                  )
     r = PayTrace::API::Request.new
     t.set_request(r)
 
-    r.params[:customer_id].must_equal "1234"
+    r.params[:customer_id].must_equal 1234
     r.params[:amount].must_equal "12.34"
 
     url = r.to_parms_string

data/test/scripts/run_create_customer.rb

@@ -0,0 +1,55 @@
+require 'paytrace'
+
+# see: http://help.paytrace.com/api-email-receipt for details
+
+#
+# Helper that loops through the response values and dumps them out
+#
+def dump_response_values(response)
+  if(response.has_errors?)
+    response.errors.each do |key, value|
+      puts "#{key.ljust(20)}#{value}"
+    end
+  else
+    response.values.each do |key, value|
+      puts "#{key.ljust(20)}#{value}"
+    end
+  end
+end
+
+PayTrace.configure do |config|
+  config.user_name = "demo123"
+  config.password = "demo123"
+  config.domain = "stage.paytrace.com"
+end
+
+# this should be a valid credit card number (it can be a "sandbox" number, however)
+cc = PayTrace::CreditCard.new({
+  card_number: "4111111111111111",
+  expiration_month: 12,
+  expiration_year: 2014
+  })
+ba = PayTrace::Address.new({
+  name: "John Doe",
+  street: "1234 Main Street",
+  street2: "Apartment 1B",
+  city: "Shoreline",
+  state: "WA",
+  country: "US",
+  postal_code: "98133",
+  address_type: :billing
+  })
+extra = {
+  email: "support@paytrace.com",
+  phone: "206-555-1212",
+  fax: "206-555-1313",
+  password: "foxtrot123",
+  account_number: 123456789,
+  routing_number: 12345678,
+  discretionary_data: "Discretionary data."
+}
+
+PayTrace::API::Gateway.set_debug(true)
+c = PayTrace::Customer.from_cc_info("john_doe", cc, ba, nil, extra)
+
+dump_response_values(PayTrace::API::Gateway.last_response)

data/test/scripts/run_email_request.rb

@@ -0,0 +1,36 @@
+require 'paytrace'
+
+# see: http://help.paytrace.com/api-email-receipt for details
+
+#
+# Helper that loops through the response values and dumps them out
+#
+def dump_response_values(response)
+  if(response.has_errors?)
+    response.errors.each do |key, value|
+      puts "#{key.ljust(20)}#{value}"
+    end
+  else
+    response.values.each do |key, value|
+      puts "#{key.ljust(20)}#{value}"
+    end
+  end
+end
+
+PayTrace.configure do |config|
+  config.user_name = "demo123"
+  config.password = "demo123"
+  config.domain = "stage.paytrace.com"
+end
+
+e = PayTrace::EmailReceiptRequest.new("support@paytrace.com", "CHECK2345", true)
+r = e.send_request
+
+# this is for the check auth version
+dump_response_values(r)
+
+e = PayTrace::EmailReceiptRequest.new("support@paytrace.com", "TRANS1234", false)
+r = e.send_request
+
+# this is for the transaction version
+dump_response_values(r)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paytrace
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Trevor Redfern
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -66,6 +66,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Integration with PayTrace Payment Gateway
 email:
 - trevor@paytrace.com
@@ -76,6 +104,7 @@ files:
 - ".gitignore"
 - ".ruby-gemset"
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -91,17 +120,25 @@ files:
 - lib/paytrace/credit_card.rb
 - lib/paytrace/customer.rb
 - lib/paytrace/email_receipt_request.rb
+- lib/paytrace/exceptions.rb
+- lib/paytrace/recurring_transaction.rb
 - lib/paytrace/transaction.rb
 - lib/paytrace/version.rb
 - paytrace.gemspec
+- test/paytrace/address_spec.rb
 - test/paytrace/api/fields_spec.rb
 - test/paytrace/api/gateway_spec.rb
 - test/paytrace/api/request_spec.rb
 - test/paytrace/api/response_spec.rb
 - test/paytrace/configuration_spec.rb
 - test/paytrace/credit_card_spec.rb
+- test/paytrace/customer_spec.rb
 - test/paytrace/email_receipt_request_spec.rb
+- test/paytrace/exceptions_spec.rb
+- test/paytrace/recurring_transaction_spec.rb
 - test/paytrace/transaction_spec.rb
+- test/scripts/run_create_customer.rb
+- test/scripts/run_email_request.rb
 - test/test_helper.rb
 - vagrant-bootstrap.sh
 homepage: http://github.com/PayTrace/paytrace_ruby
@@ -124,17 +161,23 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Integration providing access to the transaction processing API for PayTrace
 test_files:
+- test/paytrace/address_spec.rb
 - test/paytrace/api/fields_spec.rb
 - test/paytrace/api/gateway_spec.rb
 - test/paytrace/api/request_spec.rb
 - test/paytrace/api/response_spec.rb
 - test/paytrace/configuration_spec.rb
 - test/paytrace/credit_card_spec.rb
+- test/paytrace/customer_spec.rb
 - test/paytrace/email_receipt_request_spec.rb
+- test/paytrace/exceptions_spec.rb
+- test/paytrace/recurring_transaction_spec.rb
 - test/paytrace/transaction_spec.rb
+- test/scripts/run_create_customer.rb
+- test/scripts/run_email_request.rb
 - test/test_helper.rb