pin_payment 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c7b070b4634a8b7e1db258cf2453aed51f23393
-  data.tar.gz: 25fb4b21844ee2142355082d11ea250beea9fec0
+  metadata.gz: 0b482e0e3054497d152ef8302a1fa9af339834cf
+  data.tar.gz: 7394ef6e8624ac96d1db2b1e726141c0a918e4df
 SHA512:
-  metadata.gz: df77eb656111fea702bf69ee97840b97cfd4e39f90663a9045f4e6c4b93ec1695523d764453630ef8fa213406110f3744ff29073e2ee0bf2212d677fdf66f628
-  data.tar.gz: e1d6ae83373cf53c7f9ef981496eca10cb97e5e447dbc510fcb4fba6850156f277c1abae798ca155b492768cdc87705420bcb0d501336a7eb1a5411dc0db17e9
+  metadata.gz: 719872f68f5a3bdcec2f6be1368bb3a11f71281508b8b05f9a1fcc527b6c520f0a9d434e04a5b3f2bf0110dd43f5735e792c13760e67bb078a4dab931a3a774d
+  data.tar.gz: 66826324dcb94dc9bca096c36037c23d452a64068f6545dc414edbed98d98aa053e25103185fdba09db8187e781c7f449facc90111b65fbded2111fda85d00f1

data/.gitignore

@@ -1,3 +1,6 @@
 /.bundle
 /gems
 /pkg
+*.swp
+/.yardoc
+/doc

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    pin_payment (0.0.5)
+    pin_payment (0.1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     fakeweb (1.3.0)
     rake (10.0.4)
+    yard (0.8.6.1)
 
 PLATFORMS
   ruby
@@ -16,3 +17,4 @@ DEPENDENCIES
   fakeweb
   pin_payment!
   rake
+  yard

data/README.md

@@ -34,7 +34,7 @@ task is up to you), if you are only doing a single transaction, this step is
 not required (but recommended).
 
 ```ruby
-customer = PinPayment::Customer.create(email: 'foo@example.com', card_token: params[:card_token])
+customer = PinPayment::Customer.create('foo@example.com', params[:card_token])
 ```
 
 The important information from the returned object is `customer.token`. You
@@ -45,12 +45,12 @@ Now you can create charges.
 
 ```ruby
 charge = PinPayment::Charge.create(
-  customer_token: customer.token, # you can optionally pass a card_token instead
-  email:          customer.email,
-  amount:         1000,
-  currency:       'USD',
-  description:    'Widgets',
-  ip_address:     request.ip
+  customer:    customer, # or you can pass customer.token, either way
+  email:       customer.email,
+  amount:      1000,
+  currency:    'USD', # only AUD and USD are supported by pin.net.au
+  description: 'Widgets',
+  ip_address:  request.ip
 )
 
 if charge.success?
@@ -58,17 +58,81 @@ if charge.success?
 end
 ```
 
+If you don't want to create customer records and just want to create once of
+charges with the credit card data, this is quite simple also. You can do this
+in 2 steps if you like, or 1.
+
+First create the card
+
+```ruby
+card = PinPayment::Card.create(
+  number:           5520000000000000,
+  expiry_month:     5,
+  expiry_year:      2014,
+  cvc:              123,
+  name:             'Roland Robot',
+  address_line1:    '42 Sevenoaks St',
+  address_city:     'Lathlain',
+  address_postcode: 6454,
+  address_state:    'WA',
+  address_country:  'Australia'
+)
+```
+
+Once you have created the card via the API, you will have a `PinPayment::Card`
+object, and you can use the charge example code above and replace the customer
+key in the has with `:card`. The same principle applies here, you can pass
+`:card` into the charge creation as the card object, or as a simple string being
+the card token.
+
+Alternatively, you can skip the card creation step, and pass `:card` to the
+charge creation as a hash itself, it will create the card for you as part of the
+charge process. Example
+
+```ruby
+charge = PinPayment::Charge.create(
+  email:       customer.email,
+  amount:      1000,
+  currency:    'USD', # only AUD and USD are supported by pin.net.au
+  description: 'Widgets',
+  ip_address:  request.ip
+  card:        {
+    number:           5520000000000000,
+    expiry_month:     5,
+    expiry_year:      2014,
+    cvc:              123,
+    name:             'Roland Robot',
+    address_line1:    '42 Sevenoaks St',
+    address_city:     'Lathlain',
+    address_postcode: 6454,
+    address_state:    'WA',
+    address_country:  'Australia'
+  }
+)
+```
+
+You can refund charges as well, either directly on the charge object with
+`charge.refund!` or you can pass a charge object or token directory into
+`PinPayment::Refund.create`
+
+Both the Charge and Customer objects have an `all` method that you can use to
+iterate over your customers and charges. They simply return an array of their
+respective objects.
+
+They also both of course have a `find` method which takes a single argument,
+being the token. For this reason I highly suggest storing `charge.token` as your
+payment reference whenever you are creating payments. As well as storing
+`customer.token` against your customers in your own customer database.
+
 ## TODO
 
-  * `PinPayment::Card` is non existent. I haven't had a use for it myself as yet, it
-    would be easy to build and will do so if I ever see the need. But as per the
-    [guide in the documentation](https://pin.net.au/docs/guides/payment-forms),
-    for a web interface it is much better to have the `card_token` created in
-    the javascript and never have the responsibility of credit card info being
-    sent directly to your server.
-  * Neither of the models support being handed a `card` hash. The API supports
-    doing so, but as above, I've not yet had the need and have always had a
-    `card_token` handy to pass in.
+   * The `all` methods need to deal with pagination.
+   * Implement `PinPayment::Customer.charges`
+   * Implement `PinPayment::Charge.search`
+   * There is more info about a charge in a response than what the API says.
+     E.g. there is info about the fees, refund status, and trasfer status. Need
+     to find out what this data is all about. Since it's undocumented, I am
+     hesitent to implement anything that relies on it as yet.
 
 ## Testing
 
@@ -77,8 +141,15 @@ responses that I know the API gives. We're not really here to test the output of
 the API, I think we can safely assume it will always give the same output for
 the same input, and I don't really want to spam their service every time someone
 runs the test suite. Nor do I want to hard code my test API keys or expect every
-developer to create a pin account. Suggestions on improvement here are welcome
-though.
+developer to create a pin account.
+
+Having said that, you can simply jump into `test/test_helper.rb` and comment out
+the line that sets up fakeweb, then you can uncomment the lines below that and
+put your own pin.net.au test API keys into the code and run the tests. Note
+however that this will create a large amount of customers and charges in your
+test dashboard on pin.net.au.
+
+Suggestions on improvement here are welcome though.
 
 ## Contributing
 

data/lib/pin_payment/base.rb

@@ -4,21 +4,25 @@ require 'pin_payment/error'
 module PinPayment
   class Base
 
+    def initialize token, options = {}
+      self.token = token
+      self.class.parse_card_data(options).each{|k,v| send("#{k}=", v) if self.class.attributes.include?(k.to_sym) }
+    end
+
     protected
 
-    def self.post uri, options
+    def self.post uri, options = {}
       fetch Net::HTTP::Post, uri, options
     end
 
-    def self.put uri, options
+    def self.put uri, options = {}
       fetch Net::HTTP::Put, uri, options
     end
 
-    def self.get uri, options
+    def self.get uri, options = {}
       fetch Net::HTTP::Get, uri, options
     end
 
-    # TODO: Accept card as a hash that would create the card at the same time as the charge
     def self.fetch klass, uri, options
       client             = Net::HTTP.new(uri.host, uri.port)
       client.use_ssl     = true
@@ -36,7 +40,84 @@ module PinPayment
         raise Error::InvalidResponse.new(e.message)
       end
       raise(Error.create(response['error'], response['error_description'], response['messages'])) if response['error']
-      response['response']
+      response = response['response']
+      response.is_a?(Hash) ? parse_object_tokens(response) : response.map{|x| parse_object_tokens(x) }
+    end
+
+    def self.parse_card_data hash
+      hash  = hash.dup
+      card  = hash.delete('card') if hash['card']
+      card  = hash.delete(:card)  if hash[:card]
+      token = hash.delete('card_token') if hash['card_token']
+      token = hash.delete(:card_token)  if hash[:card_token]
+      if card.is_a?(Card) and token and !card.token
+        card.token = token
+      elsif card.is_a?(Hash)
+        card = Card.new(token || card[:token] || card['token'], card)
+      elsif card.is_a?(String)
+        card = Card.new(card)
+      elsif token
+        card = Card.new(token)
+      end
+      hash['card'] = card if card
+      hash
+    end
+
+    def self.parse_customer_data hash
+      hash     = hash.dup
+      customer = hash.delete('customer') if hash['customer']
+      customer = hash.delete(:customer)  if hash[:customer]
+      token    = hash.delete('customer_token') if hash['customer_token']
+      token    = hash.delete(:customer_token)  if hash[:customer_token]
+      if customer.is_a?(Customer) and token and !customer.token
+        customer.token = token
+      elsif customer.is_a?(String)
+        customer = Customer.new(customer)
+      elsif token
+        customer = Customer.new(token)
+      end
+      hash['customer'] = customer if customer
+      hash
+    end
+
+    def self.parse_charge_data hash
+      hash   = hash.dup
+      charge = hash.delete('charge') if hash['charge']
+      charge = hash.delete(:charge)  if hash[:charge]
+      token  = hash.delete('charge_token') if hash['charge_token']
+      token  = hash.delete(:charge_token)  if hash[:charge_token]
+      if charge.is_a?(Charge) and token and !charge.token
+        charge.token = token
+      elsif charge.is_a?(String)
+        charge = Charge.new(charge)
+      elsif token
+        charge = Charge.new(token)
+      end
+      hash['charge'] = charge if charge
+      hash
+    end
+
+    def self.parse_object_tokens hash
+      parse_charge_data(parse_customer_data(parse_card_data(hash)))
+    end
+
+    def self.parse_options_for_request attributes, options
+      attributes = attributes.map(&:to_s)
+      options    = parse_object_tokens(options.select{|k| attributes.include?(k.to_s) })
+
+      if card = options.delete('card')
+        if card.token
+          options['card_token'] = card.token
+        else
+          # Ruby's Net::HTTP#set_form_data doesn't deal with nested hashes :(
+          card.to_hash.each{|k,v| options["card[#{k}]"] = v }
+        end
+      end
+
+      options['customer_token'] = options.delete('customer').token if options['customer']
+      options['charge_token']   = options.delete('charge').token   if options['charge']
+
+      options
     end
 
   end

data/lib/pin_payment/card.rb

@@ -0,0 +1,43 @@
+module PinPayment
+  class Card < Base
+    attr_accessor :token,  :display_number,  :scheme,  :address_line1,  :address_line2,  :address_city,  :address_postcode,  :address_state,  :address_country
+    protected     :token=, :display_number=, :scheme=, :address_line1=, :address_line2=, :address_city=, :address_postcode=, :address_state=, :address_country=
+
+    attr_accessor :number,  :expiry_month,  :expiry_year,  :cvc,  :name
+    protected     :number,  :expiry_month,  :expiry_year,  :cvc,  :name
+    protected     :number=, :expiry_month=, :expiry_year=, :cvc=, :name=
+
+    # Use the pin API to create a credit card token, usable for 1 month from creation.
+    #
+    # @param [Hash] card_data
+    # @option card_data [#to_s] :name
+    # @option card_data [#to_s] :number
+    # @option card_data [#to_s] :cvc
+    # @option card_data [#to_s] :address_line1
+    # @option card_data [#to_s] :address_line2 (optional)
+    # @option card_data [#to_s] :address_city
+    # @option card_data [#to_s] :address_postcode
+    # @option card_data [#to_s] :address_country
+    # @option card_data [#to_s] :expiry_month
+    # @option card_data [#to_s] :expiry_year (4 digits required)
+    # @return [PinPayment::Card]
+    def self.create card_data
+      attributes = self.attributes - [:token, :display_number, :scheme] # fix attributes allowed by POST API
+      options    = parse_options_for_request(attributes, card_data)
+      response   = post(URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/cards' }, options)
+      new(response.delete('token'), response)
+    end
+
+    # @return [Hash]
+    def to_hash
+      {}.tap{|h| self.class.attributes.each{|k| v = send(k) ; h[k] = v if v }}
+    end
+
+    protected
+
+    def self.attributes
+      [:token, :display_number, :scheme, :address_line1, :address_line2, :address_city, :address_postcode, :address_state, :address_country, :number, :expiry_month, :expiry_year, :cvc, :name]
+    end
+
+  end
+end

data/lib/pin_payment/charge.rb

@@ -1,30 +1,51 @@
 module PinPayment
   class Charge < Base
-    attr_reader :token, :amount, :currency, :description, :email, :ip_address, :created_at, :card_token
+    attr_accessor :token,  :amount,  :currency,  :description,  :email,  :ip_address,  :created_at,  :card,  :customer,  :success
+    protected     :token=, :amount=, :currency=, :description=, :email=, :ip_address=, :created_at=, :card=, :customer=, :success=
 
-    def self.create options
-      response = self.post(
-        URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/charges' },
-        options.select{|k| %w(amount currency description email ip_address card_token customer_token).include?(k.to_s) }
-      )
-      self.new.tap do |charge|
-        charge.instance_variable_set('@card_token', response['card']['token']) if response['card']
-        %w(token amount currency description email ip_address created_at error_message success).each do |key|
-          charge.instance_variable_set("@#{key}", response[key])
-        end
-      end
+    # Uses the pin API to create a charge.
+    #
+    # @param [Hash] charge_data
+    # @option charge_data [String] :amount *required*
+    # @option charge_data [String] :currency *required* only AUD and USD supported
+    # @option charge_data [String] :email *required*
+    # @option charge_data [String] :description *required*
+    # @option charge_data [String] :ip_address *required*
+    # @option charge_data [String, PinPayment::Customer] :customer can be a customer token or a customer object
+    # @option charge_data [String, PinPayment::Card, Hash] :card can be a card token, hash or a card object
+    # @return [PinPayment::Charge]
+    def self.create charge_data
+      attributes = self.attributes - [:token, :success, :created_at] # fix attributes allowed by POST API
+      options    = parse_options_for_request(attributes, charge_data)
+      response   = post(URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/charges' }, options)
+      new(response.delete('token'), response)
     end
 
+    # Fetches all of your charges using the pin API.
+    #
+    # @return [Array<PinPayment::Charge>]
+    # TODO: pagination
+    def self.all
+      response = get(URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/charges' })
+      response.map{|x| new(x.delete('token'), x) }
+    end
+
+    # Refund a charge via the pin API.
+    #
+    # @return [PinPayment::Refund]
     def refund!
-      Refund.create(charge_token: token)
+      Refund.create self
     end
 
+    # @return [Boolean]
     def success?
-      @success == true
+      success == true
     end
 
-    def errors
-      @error_message
+    protected
+
+    def self.attributes
+      [:token, :amount, :currency, :description, :email, :ip_address, :created_at, :card, :customer, :success]
     end
   end
 end

data/lib/pin_payment/customer.rb

@@ -1,32 +1,66 @@
 module PinPayment
   class Customer < Base
-    attr_reader :token, :email, :created_at, :card_token
-
-    def self.create options
-      response = post(
-        URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/customers' },
-        options.select{|k| %w(email card_token).include?(k.to_s) }
-      )
-      new.tap do |customer|
-        customer.instance_variable_set('@card_token', response['card']['token']) if response['card']
-        %w(token email created_at).each do |key|
-          customer.instance_variable_set("@#{key}", response[key])
-        end
-      end
+    attr_accessor :token,  :email,  :created_at,  :card
+    protected     :token=, :email=, :created_at=, :card=
+
+    # Uses the pin API to create a customer.
+    #
+    # @param [String] email the customer's email address
+    # @param [String, PinPayment::Card, Hash] card_or_token the customer's credit card details
+    # @return [PinPayment::Customer]
+    def self.create email, card_or_token = nil
+      attributes = self.attributes - [:token, :created_at]
+      options    = parse_options_for_request(attributes, email: email, card: card_or_token)
+      response   = post(URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/customers' }, options)
+      new(response.delete('token'), response)
+    end
+
+    # Update a customer using the pin API.
+    #
+    # @param [String] token the customer token
+    # @param [String] email the customer's new email address
+    # @param [String, PinPayment::Card, Hash] card_or_token the customer's new credit card details
+    # @return [PinPayment::Customer]
+    def self.update token, email, card_or_token = nil
+      new(token).tap{|c| c.update(email, card_or_token) }
+    end
+
+    # Fetches a customer using the pin API.
+    #
+    # @param [String] token the customer token
+    # @return [PinPayment::Customer]
+    def self.find token
+      response = get(URI.parse(PinPayment.api_url).tap{|uri| uri.path = "/1/customers/#{token}" })
+      new(response.delete('token'), response)
     end
 
-    def self.update options
-      # PUT /1/customers/cus_XZg1ULpWaROQCOT5PdwLkQ
-      response = put(
-        URI.parse(PinPayment.api_url).tap{|uri| uri.path = "/1/customers/#{options[:token] || options['token']}" },
-        options.select{|k| %w(email card_token).include?(k.to_s) }
-      )
-      new.tap do |customer|
-        customer.instance_variable_set('@card_token', response['card']['token']) if response['card']
-        %w(token email created_at).each do |key|
-          customer.instance_variable_set("@#{key}", response[key])
-        end
-      end
+    # Fetches all of your customers using the pin API.
+    #
+    # @return [Array<PinPayment::Customer>]
+    # TODO: pagination
+    def self.all
+      response = get(URI.parse(PinPayment.api_url).tap{|uri| uri.path = '/1/customers' })
+      response.map{|x| new(x.delete('token'), x) }
+    end
+
+    # Update a customer using the pin API.
+    #
+    # @param [String] email the customer's new email address
+    # @param [String, PinPayment::Card, Hash] card_or_token the customer's new credit card details
+    # @return [PinPayment::Customer]
+    def update email, card_or_token = nil
+      attributes = self.class.attributes - [:token, :created_at]
+      options    = self.class.parse_options_for_request(attributes, email: email, card: card_or_token)
+      response   = self.class.put(URI.parse(PinPayment.api_url).tap{|uri| uri.path = "/1/customers/#{token}" }, options)
+      self.email = response['email']
+      self.card  = response['card']
+      self
+    end
+
+    protected
+
+    def self.attributes
+      [:token, :email, :created_at, :card]
     end
 
   end

data/lib/pin_payment/refund.rb

@@ -1,19 +1,19 @@
 module PinPayment
   class Refund < Base
-    attr_reader :token, :amount, :currency, :charge_token, :created_at
+    attr_accessor :token,  :amount,  :currency,  :charge,  :created_at,  :status_message
+    protected     :token=, :amount=, :currency=, :charge=, :created_at=, :status_message=, :status_message
 
-    def self.create options
-      response = self.post(
-        URI.parse(PinPayment.api_url).tap{|uri| uri.path = "/1/charges/#{options[:charge_token] || options['charge_token']}/refunds" },
-        {}
-      )
-      self.new.tap do |charge|
-        %w(token amount currency created_at error_message status_message).each do |key|
-          charge.instance_variable_set("@#{key}", response[key])
-        end
-      end
+    # Uses the pin API to create a refund.
+    #
+    # @param [String, PinPayment::Charge] charge_or_token the charge (or token of the charge) to refund
+    # @return [PinPayment::Refund]
+    def self.create charge_or_token
+      token = charge_or_token.is_a?(Charge) ? charge_or_token.token : charge_or_token
+      response = post(URI.parse(PinPayment.api_url).tap{|uri| uri.path = "/1/charges/#{token}/refunds" })
+      new(response.delete('token'), response)
     end
 
+    # @return [Boolean]
     # TODO: API documentation only shows success as being "null" in the JSON
     # response, so not sure this is possible. All my refunds on the test site
     # end up in a "Pending" state so not entirely sure on this one.
@@ -21,12 +21,15 @@ module PinPayment
       @success == true
     end
 
+    # @return [String]
     def status
-      @status_message
+      status_message
     end
 
-    def errors
-      @error_message
+    protected
+
+    def self.attributes
+      [:token, :amount, :currency, :charge, :created_at, :status_message]
     end
   end
 end

data/lib/pin_payment/version.rb

@@ -1,8 +1,8 @@
 module PinPayment
   module Version
     MAJOR = 0
-    MINOR = 0
-    PATCH = 5
+    MINOR = 1
+    PATCH = 0
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

data/lib/pin_payment.rb

@@ -1,4 +1,5 @@
 require 'pin_payment/base'
+require 'pin_payment/card'
 require 'pin_payment/charge'
 require 'pin_payment/customer'
 require 'pin_payment/error'

data/pin_payment.gemspec

@@ -14,6 +14,7 @@ spec = Gem::Specification.new do |s|
 
   s.add_development_dependency('fakeweb')
   s.add_development_dependency('rake')
+  s.add_development_dependency('yard')
 
   s.required_ruby_version = '>= 1.9.2'
 

data/test/fixtures/responses.yml

@@ -3,13 +3,17 @@ charge:
   token_already_used: '{"error":"token_already_used","error_description":"Token already used. Card tokens can only be used once, to create a charge or assign a card to a customer."}'
   invalid_amount: '{"error":"invalid_resource","error_description":"One or more parameters were missing or invalid.","messages":[{"param":"amount","code":"amount_invalid","message":"Amount must be an integer"},{"param":"amount","code":"amount_invalid","message":"Amount must be more than 1 USD"}]}'
   success: '{"response":{"token":"ch_BjGW-S6WUisI6mOgpDRimg","success":true,"amount":1000,"currency":"USD","description":"Widgets","email":"foo@example.com","ip_address":"127.0.0.1","created_at":"2013-06-12T23:55:38Z","status_message":"Success!","error_message":null,"card":{"token":"card_qMwnMfpG-olOhfJeyxmrcg","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"},"transfer":[],"amount_refunded":0,"total_fees":null,"merchant_entitlement":null,"refund_pending":false}}'
-update_customer:
+  create_with_card: '{"response":{"token":"ch_lfUYEBK14zotCTykezJkfg","success":true,"amount":400,"currency":"AUD","description":"test charge","email":"roland@pin.net.au","ip_address":"203.192.1.172","created_at":"2013-06-27T00:39:07Z","status_message":"Success","error_message":null,"card":{"token":"card_jxk5A8fjTtmz6Y81NX9G7w","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"42 Sevenoaks St","address_line2":null,"address_city":"Lathlain","address_postcode":"6454","address_state":"WA","address_country":"Australia"},"transfer":null}}'
+  all: '{"response":[{"token":"ch_lfUYEBK14zotCTykezJkfg","success":true,"amount":400,"currency":"AUD","description":"test charge","email":"roland@pin.net.au","ip_address":"203.192.1.172","created_at":"2013-06-27T00:39:07Z","status_message":"Success","error_message":null,"card":{"token":"card_nytGw7koRg23EEp9NTmz9w","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"42 Sevenoaks St","address_line2":null,"address_city":"Lathlain","address_postcode":"6454","address_state":"WA","address_country":"Australia"},"transfer":null},{"token":"ch_shldvbE5eqBQuyY9Fryhzw","success":true,"amount":400,"currency":"AUD","description":"test charge","email":"roland@pin.net.au","ip_address":"203.192.1.172","created_at":"2013-06-27T00:38:41Z","status_message":"Success","error_message":null,"card":{"token":"card_nytGw7koRg23EEp9NTmz9w","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"42 Sevenoaks St","address_line2":null,"address_city":"Lathlain","address_postcode":"6454","address_state":"WA","address_country":"Australia"},"transfer":null}],"count":2,"pagination":{"current":1,"previous":null,"next":1,"per_page":25,"pages":1,"count":2}}'
+customer:
   blank_email: '{"error":"invalid_resource","error_description":"One or more parameters were missing or invalid.","messages":[{"param":"email","code":"email_invalid","message":"Email can''t be blank"}]}'
-  blank_token: '{"error":"resource_not_found","error_description":"No resource was found at this URL. See https://pin.net.au/docs/api for API documentation and a list of valid URLs."}'
-  success: '{"response":{"token":"cus__03Cn1lSk3offZ0IGkwpCg","email":"foo@example.com","created_at":"2013-06-12T10:08:30Z","card":{"token":"card_qMwnMfpG-olOhfJeyxmrcg","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"}}}'
-create_customer:
-  blank_email: '{"error":"invalid_resource","error_description":"One or more parameters were missing or invalid.","messages":[{"param":"email","code":"email_invalid","message":"Email can''t be blank"}]}'
-  success: '{"response":{"token":"cus__03Cn1lSk3offZ0IGkwpCg","email":"foo@example.com","created_at":"2013-06-12T10:08:30Z","card":{"token":"card_qMwnMfpG-olOhfJeyxmrcg","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"}}}'
+  updated: '{"response":{"token":"cus__03Cn1lSk3offZ0IGkwpCg","email":"changed@example.com","created_at":"2013-06-12T10:08:30Z","card":{"token":"card_qMwnMfpG-olOhfJeyxmrcg","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"}}}'
+  created: '{"response":{"token":"cus__03Cn1lSk3offZ0IGkwpCg","email":"foo@example.com","created_at":"2013-06-12T10:08:30Z","card":{"token":"card_qMwnMfpG-olOhfJeyxmrcg","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"}}}'
+  all: '{"response":[{"token":"cus_OEHdj9KE_OiC9eig0h3IEA","email":"user1@example.com","created_at":"2013-06-25T04:14:35Z","card":{"token":"card_7rviJ2IZM__WC9Dnj0RHJA","display_number":"XXXX-XXXX-XXXX-0000","scheme":"visa","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"}},{"token":"cus_cO2VtF4YzK6i1QBcLsdzOA","email":"user2@example.com","created_at":"2013-06-24T05:53:42Z","card":{"token":"card_bVou2J4hzbDIwe-sQ3ZqdQ","display_number":"XXXX-XXXX-XXXX-0000","scheme":"visa","address_line1":"123 Main St","address_line2":"","address_city":"Melbourne","address_postcode":"3000","address_state":"Victoria","address_country":"Australia"}}],"count":2,"pagination":{"current":1,"previous":null,"next":null,"per_page":25,"pages":1,"count":2}}'
+  create_with_card: '{"response":{"token":"cus_XZg1ULpWaROQCOT5PdwLkQ","email":"roland@pin.net.au","created_at":"2013-06-27T00:24:43Z","card":{"token":"card_nytGw7koRg23EEp9NTmz9w","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"42 Sevenoaks St","address_line2":null,"address_city":"Lathlain","address_postcode":"6454","address_state":"WA","address_country":"Australia"}}}'
 refund:
   success: '{"response":{"token":"rf_wMYx5YHKaZAwQgj5rtNuTg","success":null,"amount":1000,"currency":"USD","charge":"ch_BjGW-S6WUisI6mOgpDRimg","created_at":"2013-06-25T03:16:33Z","error_message":null,"status_message":"Pending"}}'
   duplicate: '{"error":"invalid_resource","error_description":"One or more parameters were missing or invalid.","messages":{"charge":["You have tried to refund more than the original charge"]}}'
+card:
+  success: '{"response":{"token":"card_nytGw7koRg23EEp9NTmz9w","display_number":"XXXX-XXXX-XXXX-0000","scheme":"master","address_line1":"42 Sevenoaks St","address_line2":null,"address_city":"Lathlain","address_postcode":"6454","address_state":"WA","address_country":"Australia"}}'
+  invalid: '{"error":"invalid_resource","error_description":"One or more parameters were missing or invalid.","messages":[{"param":"number","code":"number_invalid","message":"Number is not a valid credit card number"}]}'

data/test/test_helper.rb

@@ -9,3 +9,44 @@ def fixtures
     f['responses'] = YAML.load(File.read File.join(File.dirname(__FILE__), 'fixtures', 'responses.yml'))
   end
 end
+
+def common_setup
+  FakeWeb.allow_net_connect = false
+
+  # If you want to test for realsies, change the above to true, and uncomment
+  # below, after putting in your own test keys
+
+  #PinPayment.secret_key = 'super secret'
+  #PinPayment.public_key = 'not so secret'
+end
+
+def card_hash
+  {
+    number:           5520000000000000,
+    expiry_month:     5,
+    expiry_year:      2014,
+    cvc:              123,
+    name:             'Roland Robot',
+    address_line1:    '42 Sevenoaks St',
+    address_city:     'Lathlain',
+    address_postcode: 6454,
+    address_state:    'WA',
+    address_country:  'Australia'
+  }
+end
+
+def charge_hash
+  {
+    amount:      400,
+    currency:    'AUD',
+    description: 'test charge',
+    email:       'roland@pin.net.au',
+    ip_address:  '203.192.1.172',
+    card:        card_hash
+  }
+end
+
+def created_customer
+  FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/customers', body: fixtures['responses']['customer']['created'])
+  customer = PinPayment::Customer.create('foo@example.com', card_hash)
+end

data/test/test_pin_card.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class TestPinCard < MiniTest::Unit::TestCase
+  def setup
+    common_setup
+  end
+
+  def test_successful_card
+    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/cards', body: fixtures['responses']['card']['success'])
+    card = PinPayment::Card.create(card_hash)
+    assert_equal 'XXXX-XXXX-XXXX-0000', card.display_number
+    assert_equal 'master', card.scheme
+  end
+
+  def test_invalid_card
+    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/cards', body: fixtures['responses']['card']['invalid'])
+    assert_raises PinPayment::Error::InvalidResource do
+      PinPayment::Card.create(card_hash.merge(number: 5520000000000099))
+    end
+  end
+
+  def test_new_from_hash
+    card = PinPayment::Card.new(nil, card_hash)
+    assert_kind_of PinPayment::Card, card
+  end
+
+  def test_to_hash
+    card = PinPayment::Card.new(nil, card_hash)
+    assert_kind_of Hash, card.to_hash
+  end
+end

data/test/test_pin_charge.rb

@@ -2,19 +2,35 @@ require 'test_helper'
 
 class TestPinCharge < MiniTest::Unit::TestCase
   def setup
-    FakeWeb.allow_net_connect = false
+    common_setup
   end
 
   def test_invalid_amount
     FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/charges', body: fixtures['responses']['charge']['invalid_amount'])
     assert_raises PinPayment::Error::InvalidResource do
-      PinPayment::Charge.create(customer_token: 'cus__03Cn1lSk3offZ0IGkwpCg', amount: 10.0)
+      PinPayment::Charge.create(charge_hash.merge(amount: 10.1))
     end
   end
 
   def test_successful_charge
     FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/charges', body: fixtures['responses']['charge']['success'])
-    charge = PinPayment::Charge.create(customer_token: 'cus__03Cn1lSk3offZ0IGkwpCg', amount: 1000)
+    charge = PinPayment::Charge.create(charge_hash)
     assert_equal true, charge.success?
   end
+
+  def test_create_charge_with_card_hash
+    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/charges', body: fixtures['responses']['charge']['create_with_card'])
+    charge = PinPayment::Charge.create(charge_hash)
+    assert_equal true, charge.success?
+    assert_kind_of PinPayment::Card, charge.card
+    assert_kind_of String, charge.card.token
+    assert charge.card.token.length > 0
+  end
+
+  def test_fetch_all_charges
+    FakeWeb.register_uri(:get, 'https://test-api.pin.net.au/1/charges', body: fixtures['responses']['charge']['all'])
+    charges = PinPayment::Charge.all
+    assert_kind_of Array, charges
+    assert_kind_of PinPayment::Charge, charges.first
+  end
 end

data/test/test_pin_customer.rb

@@ -2,39 +2,54 @@ require 'test_helper'
 
 class TestPinCustomer < MiniTest::Unit::TestCase
   def setup
-    FakeWeb.allow_net_connect = false
+    common_setup
   end
 
-  def test_update_with_blank_email
-    FakeWeb.register_uri(:put, 'https://test-api.pin.net.au/1/customers/cus__03Cn1lSk3offZ0IGkwpCg', body: fixtures['responses']['update_customer']['blank_email'])
+  def test_create_with_blank_email
+    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/customers', body: fixtures['responses']['customer']['blank_email'])
     assert_raises PinPayment::Error::InvalidResource do
-      PinPayment::Customer.update(token: 'cus__03Cn1lSk3offZ0IGkwpCg', email: nil)
+      PinPayment::Customer.create(email: nil, card: card_hash)
     end
   end
 
-  def test_update_with_blank_token
-    FakeWeb.register_uri(:put, 'https://test-api.pin.net.au/1/customers/', body: fixtures['responses']['update_customer']['blank_token'])
-    assert_raises PinPayment::Error::ResourceNotFound do
-      PinPayment::Customer.update(email: 'foo@example.com')
-    end
+  def test_create_success
+    customer = created_customer
+    assert_kind_of PinPayment::Customer, customer
   end
 
-  def test_create_with_blank_email
-    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/customers', body: fixtures['responses']['create_customer']['blank_email'])
-    assert_raises PinPayment::Error::InvalidResource do
-      PinPayment::Customer.create(email: nil)
-    end
+  def test_direct_update
+    customer = created_customer
+    FakeWeb.register_uri(:put, "https://test-api.pin.net.au/1/customers/#{customer.token}", body: fixtures['responses']['customer']['updated'])
+    customer = PinPayment::Customer.update(customer.token, 'changed@example.com')
+    assert_equal 'changed@example.com', customer.email
   end
 
-  def test_create_success
-    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/customers', body: fixtures['responses']['create_customer']['success'])
-    customer = PinPayment::Customer.create(email: 'foo@example.com')
-    assert_equal customer.token, 'cus__03Cn1lSk3offZ0IGkwpCg'
+  def test_object_update
+    customer = created_customer
+    FakeWeb.register_uri(:put, "https://test-api.pin.net.au/1/customers/#{customer.token}", body: fixtures['responses']['customer']['updated'])
+    customer.update('changed@example.com')
+    assert_equal 'changed@example.com', customer.email
+  end
+
+  def test_find_customer
+    customer = created_customer
+    FakeWeb.register_uri(:get, "https://test-api.pin.net.au/1/customers/#{customer.token}", body: fixtures['responses']['customer']['created'])
+    customer = PinPayment::Customer.find(customer.token)
+    assert_kind_of PinPayment::Customer, customer
+  end
+
+  def test_fetch_all_customers
+    FakeWeb.register_uri(:get, 'https://test-api.pin.net.au/1/customers', body: fixtures['responses']['customer']['all'])
+    customers = PinPayment::Customer.all
+    assert_kind_of Array, customers
+    assert_kind_of PinPayment::Customer, customers.first
   end
 
-  def test_update_success
-    FakeWeb.register_uri(:put, 'https://test-api.pin.net.au/1/customers/cus__03Cn1lSk3offZ0IGkwpCg', body: fixtures['responses']['update_customer']['success'])
-    customer = PinPayment::Customer.update(token: 'cus__03Cn1lSk3offZ0IGkwpCg', email: 'foo@example.com')
-    assert_equal customer.token, 'cus__03Cn1lSk3offZ0IGkwpCg'
+  def test_create_customer_with_card_hash
+    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/customers', body: fixtures['responses']['customer']['create_with_card'])
+    customer = PinPayment::Customer.create('roland@pin.net.au', card_hash)
+    assert_kind_of PinPayment::Card, customer.card
+    assert_kind_of String, customer.card.token
+    assert customer.card.token.length > 0
   end
 end

data/test/test_pin_refund.rb

@@ -2,30 +2,29 @@ require 'test_helper'
 
 class TestPinRefund < MiniTest::Unit::TestCase
   def setup
-    FakeWeb.allow_net_connect = false
+    common_setup
+    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/charges', body: fixtures['responses']['charge']['success'])
+    @charge = PinPayment::Charge.create(charge_hash)
   end
 
   def test_duplicate_refund
-    token = 'ch_BjGW-S6WUisI6mOgpDRimg'
-    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{token}/refunds", body: fixtures['responses']['refund']['duplicate'])
+    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{@charge.token}/refunds", body: fixtures['responses']['refund']['success'])
+    PinPayment::Refund.create(@charge)
+    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{@charge.token}/refunds", body: fixtures['responses']['refund']['duplicate'])
     assert_raises PinPayment::Error::InvalidResource do
-      PinPayment::Refund.create(charge_token: token)
+      PinPayment::Refund.create(@charge)
     end
   end
 
-  def test_manual_refund
-    token = 'ch_BjGW-S6WUisI6mOgpDRimg'
-    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{token}/refunds", body: fixtures['responses']['refund']['success'])
-    refund = PinPayment::Refund.create(charge_token: token)
+  def test_direct_refund
+    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{@charge.token}/refunds", body: fixtures['responses']['refund']['success'])
+    refund = PinPayment::Refund.create(@charge.token)
     assert_equal 'Pending', refund.status
   end
 
-  def test_charge_refund
-    FakeWeb.register_uri(:post, 'https://test-api.pin.net.au/1/charges', body: fixtures['responses']['charge']['success'])
-    charge = PinPayment::Charge.create(customer_token: 'cus__03Cn1lSk3offZ0IGkwpCg', amount: 1000)
-
-    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{charge.token}/refunds", body: fixtures['responses']['refund']['success'])
-    refund = charge.refund!
+  def test_object_refund
+    FakeWeb.register_uri(:post, "https://test-api.pin.net.au/1/charges/#{@charge.token}/refunds", body: fixtures['responses']['refund']['success'])
+    refund = @charge.refund!
     assert_equal 'Pending', refund.status
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pin_payment
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Danial Pearce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2013-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fakeweb
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: Pin is the easiest way to accept payments online.  See https://pin.net.au/
   for details.
 email:
@@ -54,6 +68,7 @@ files:
 - Rakefile
 - lib/pin_payment.rb
 - lib/pin_payment/base.rb
+- lib/pin_payment/card.rb
 - lib/pin_payment/charge.rb
 - lib/pin_payment/customer.rb
 - lib/pin_payment/error.rb
@@ -62,6 +77,7 @@ files:
 - pin_payment.gemspec
 - test/fixtures/responses.yml
 - test/test_helper.rb
+- test/test_pin_card.rb
 - test/test_pin_charge.rb
 - test/test_pin_customer.rb
 - test/test_pin_refund.rb
@@ -93,7 +109,9 @@ summary: Ruby bindings for the Pin API
 test_files:
 - test/fixtures/responses.yml
 - test/test_helper.rb
+- test/test_pin_card.rb
 - test/test_pin_charge.rb
 - test/test_pin_customer.rb
 - test/test_pin_refund.rb
 - test/test_pin_setup.rb
+has_rdoc: