pin-payments 0.0.3 → 1.0

data/README.md

@@ -1,12 +1,6 @@
 ## pin-payments
 
-A wrapper for the [pin.net.au](https://pin.net.au/) [API](https://pin.net.au/docs/api). Available via [RubyGems](http://rubygems.org/gems/pin-payments):
-
-    gem install pin-payments
-
-Extracted from [PayAus](http://www.payaus.com/). Still a bit rough around the edges.
-
-MIT licensed, contributions are very welcome!
+A wrapper for the [pin.net.au](https://pin.net.au/) [API](https://pin.net.au/docs/api). MIT licensed.
 
 ## Usage
 
@@ -16,47 +10,104 @@ You'll need to create an account at [pin.net.au](https://pin.net.au/) first.
 
 ### Setup
 
-Create an initializer, eg. `pin.rb`:
+Create an initializer, eg. `pin.rb`, using keys from Pin's [Your Account](https://dashboard.pin.net.au/account) page.
 
 ```ruby
-Pin::Base.setup ENV['PIN_SECRET_KEY'], ENV['PIN_ENV']
+Pin.setup secret_key: 'PIN_SECRET_KEY', publishable_key: 'PIN_PUBLISHABLE_KEY', mode: :test
 ```
 
-You can get your secret key from Pin's [Your Account](https://dashboard.pin.net.au/account) page. The second argument should be "live" or "test" depending on which API you want to access.
+The `mode` should be `:live` or `:test` depending on which API you want to access. The `publishable_key` is optional.
+
+Alternatively, you could fetch keys from a YAML file, e.g. like this initializer:
+
+```ruby
+pin_config_path = Rails.root.join 'config', 'pin.yml'
+if File.exists?(pin_config_path)
+  configuration = YAML.load_file(pin_config_path)
+  raise "No environment configured for Pin for RAILS_ENV=#{Rails.env}" unless configuration[Rails.env]
+  Pin.setup configuration[Rails.env].symbolize_keys
+end
+```
+
+and then in `config/pin.yml`:
+
+```yaml
+test:
+  secret_key: "TEST_API_SECRET"
+  publishable_key: "TEST_PUBLISHABLE_KEY"
+  mode: "test"
+
+development:
+  secret_key: "TEST_API_SECRET"
+  publishable_key: "TEST_PUBLISHABLE_KEY"
+  mode: "test"
+
+production:
+  secret_key: "LIVE_API_SECRET"
+  publishable_key: "LIVE_PUBLISHABLE_KEY"
+  mode: "live"
+```
+
+This allows you to inject `pin.yml` at deployment time, so that the secret key can be kept separate from your codebase.
 
 ### Usage
 
-You'll probably want to create a form through which users can enter their details. [Pin's guide](https://pin.net.au/docs/guides/payment-forms) will step you through this.
+You'll probably want to create a form through which users can enter their details. [Pin's guide](https://pin.net.au/docs/guides/payment-forms) will step you through this. The publishable key will be necessary and, if set, can be obtained by calling `Pin.publishable_key`. You can also ask the module for the path to the javascript for the configured mode:
+
+```erb
+<%= javascript_include_tag Pin.js_url %>
+```
 
-Then, in your controller:
+Creating a charge is simple. In your controller:
 
 ```ruby
 def create
-  Pin::Charge.create email: 'alex@payaus.com', description: '1 month of service', amount: 19900,
+  Pin::Charge.create email: 'user@example.com', description: '1 year of service', amount: 10000,
                      currency: 'AUD', ip_address: params[:ip_address], card_token: params[:card_token]
+
   redirect_to new_payment_path, notice: "Your credit card has been charged"
 end
 ```
 
-This will issue a once-off charge ([API](https://pin.net.au/docs/api/charges)). Alternatively, you may wish to create a customer. To do this, create a `Card` object first, then a corresponding `Customer` via the [API](https://pin.net.au/docs/api/customers).
+This will issue a once-off charge ([API](https://pin.net.au/docs/api/charges)).
+
+For a recurring charge, you may wish to create a customer record at Pin. To do this, either create a `Card` object first, then a corresponding `Customer` via the [API](https://pin.net.au/docs/api/customers); or use a `card_token` returned from `Pin.js` to create a customer. Note that in either case you may activate additional compliance provisions in Pin's [Terms & Conditions](https://pin.net.au/terms).
 
 ```ruby
-card = Pin::Card.new number: '5520000000000000', expiry_month: '12', 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'
-customer = Pin::Customer.create 'alex@payaus.com', card # this contacts the API
-Pin::Charge.create email: 'alex@payaus.com', description: '1 month of service', amount: 19900,
-                   currency: 'AUD', ip_address: '203.192.1.172', customer: customer # shorthand for customer_token: customer.token
+# this doesn't contact the API
+card = Pin::Card.new number: '5520000000000000', expiry_month: '12', expiry_year: '2018', cvc: '123',
+                     name: 'User Name', address_line1: 'GPO Box 1234', address_city: 'Melbourne', address_postcode: '3001', address_state: 'VIC', address_country: 'Australia'
+
+# this contacts the API and returns a customer
+customer = Pin::Customer.create 'user@example.com', card
+
+# this contacts the API and returns a charge
+Pin::Charge.create email: 'user@example.com', description: '1 year of service', amount: 10000,
+                   currency: 'AUD', ip_address: '127.0.0.1', customer: customer # shorthand for customer_token: customer.token
 ```
 
 You can view your customers in the [Pin dashboard](https://dashboard.pin.net.au/test/customers). This lets you charge customers regularly without asking for their credit card details each time.
 
 ```ruby
+# get all customers from the API
 customers = Pin::Customer.all
-customer = customers.find {|c| c.email == user.email} # assume user is the user you are trying to charge
-Pin::Charge.create email: user.email, description: '1 month of service', amount: 19900, currency: 'AUD',
-                   ip_address: user.ip_address, customer: customer
+
+# find the customer you are trying to charge, assuming `current_user` is defined elsewhere
+customer = customers.find {|c| c.email == current_user.email}
+
+# create a charge for the customer
+# note that using this method you will need to store the `ip_address` of the user
+# generally you can store this from when you initially created the customer (via Pin.js)
+Pin::Charge.create email: user.email, description: '1 month of service', amount: 19900,
+                   currency: 'AUD', ip_address: user.ip_address, customer: customer
 ```
 
-## Credits
+Errors from the API will result in a`Pin::APIError` exception being thrown:
 
-https://github.com/ghiculescu/pin-payments/graphs/contributors
+```ruby
+begin
+  response = Pin::Charge.create( ... )
+rescue Pin::APIError => e
+  redirect_to new_payment_path, flash: { error: "Charge failed: #{e.message}" }
+end
+```

data/lib/pin-payments.rb

@@ -2,6 +2,51 @@ require 'httparty'
 require 'json'
 
 require 'pin-payments/base'
+require 'pin-payments/response'
 require 'pin-payments/card'
 require 'pin-payments/charge'
-require 'pin-payments/customer'
+require 'pin-payments/customer'
+require 'pin-payments/refund'
+
+module Pin
+  class Error < StandardError; end
+  class APIError < Error
+    attr_reader :code, :error, :description, :response
+    
+    def initialize(response)
+      @code = response.code
+      @error = response['error']
+      @description = response['description']
+      @response = response
+    end
+    
+    def to_s
+      "#@code #@error #@description"
+    end
+  end
+  
+  class << self
+    attr_reader :publishable_key, :js_url, :auth
+
+    def setup(options)
+      raise ArgumentError, "Pin.setup wants an options hash" unless Hash === options
+      raise ArgumentError, "no secret key configured" unless options[:secret_key]
+      raise ArgumentError, "no mode configured" unless options[:mode]
+    
+      @auth = {username: options[:secret_key], password: ''}
+      @publishable_key = options[:publishable_key]
+    
+      mode = options[:mode].to_sym
+      uri = if mode == :live
+        "https://api.pin.net.au"
+      elsif mode == :test
+        "https://test-api.pin.net.au"
+      else
+        raise ArgumentError, "Incorrect API mode! Must be :live or :test"
+      end
+    
+      @js_url = "#{uri}/pin.js"
+      Pin::Base.base_uri "#{uri}/1"
+    end
+  end
+end

data/lib/pin-payments/base.rb

@@ -12,39 +12,75 @@ module Pin
       end
     end
 
-    def self.setup(key, mode = :live)
-      @@auth = {username: key, password: ''}
-      mode = mode.to_sym
-      uri = if mode == :test
-        "https://test-api.pin.net.au/1"
-      elsif mode == :live
-        "https://api.pin.net.au/1"
-      else
-        raise "Incorrect API mode! Must be :live or :test (leave blank for :live)."
-      end
-      base_uri uri
-    end
+    class << self
+
+      def create(options, path = api_path)
+        response = authenticated_post(path, options)
+        if response.code == 201 # object created
+          build_instance_from_response(response)
+        else
+          raise Pin::APIError.new(response)
+        end
+      end
+      
+      def all(options = {})
+        options = {path: api_path, page: 1}.merge(options)
+        paging = "page=#{options[:page]}" unless options[:page] == 1
+        build_collection_from_response(authenticated_get(options[:path], paging))
+      end
+
+      def all_pages(options = {})
+        options = options.merge(path: api_path)
+      end
+
+      def first(options = {})
+        all(options).first
+      end
+      def last(options = {})
+        all(options).last
+      end
 
+      def find(token, options = {})
+        options = options.merge(path: api_path)
+        build_instance_from_response(authenticated_get("#{options[:path]}/#{token}"))
+      end
+    
     protected
-    def self.authenticated_post(url, body)
-      post(url, body: body, basic_auth: @@auth)
-    end
-    def self.authenticated_get(url, query = nil)
-      get(url, query: query, basic_auth: @@auth)
-    end
+    
+      def auth
+        Pin.auth
+      end
+    
+      def api_path
+        short = if i = name.rindex('::')
+          name[(i+2)..-1]
+        else
+          name
+        end
+        "/#{short}s".downcase
+      end
+    
+      def authenticated_post(url, body)
+        post(url, body: body, basic_auth: auth)
+      end
+      def authenticated_get(url, query = nil)
+        get(url, query: query, basic_auth: auth)
+      end
 
-    def self.build_instance_from_response(response)
-      new(response.parsed_response['response'])
-    end
+      def build_instance_from_response(response)
+        new(response.parsed_response['response'])
+      end
 
-    def self.build_collection_from_response(response)
-      models = []
-      if response.code == 200
-        response.parsed_response['response'].each do |model|
-          models << new(model)
+      def build_collection_from_response(response)
+        models = []
+        if response.code == 200
+          response.parsed_response['response'].each do |model|
+            models << new(model)
+          end
         end
+        pg = response.parsed_response['pagination']
+        CollectionResponse.new(models, pg['per_page'], pg['pages'], pg['current'])
       end
-      models
     end
   end
 end

data/lib/pin-payments/card.rb

@@ -15,19 +15,15 @@ module Pin
       hash
     end
 
-    # options should be a hash with the following keys:
-    # :number, :expiry_month, :expiry_year, :cvc, :name, :address_line1,
-    # :address_city, :address_postcode, :address_state, :address_country
-    #
-    # it can also have the following optional keys:
-    # :address_line2
-    def self.create(options = {})
-      response = authenticated_post '/cards', options
-      if response.code == 201 # card created
-        build_instance_from_response(response)
-      else
-        # handle the error
-        false
+    class << self
+      # options should be a hash with the following keys:
+      # :number, :expiry_month, :expiry_year, :cvc, :name, :address_line1,
+      # :address_city, :address_postcode, :address_state, :address_country
+      #
+      # it can also have the following optional keys:
+      # :address_line2
+      def create(options = {})
+        super(options)
       end
     end
   end

data/lib/pin-payments/charge.rb

@@ -6,25 +6,33 @@ module Pin
                   :amount_refunded, :total_fees, :merchant_entitlement, :refund_pending,
                   :success, :status_message, :error_message, :transfer, :created_at
 
-    # options should be a hash with the following params
-    # email, description, amount, currency, ip_address are mandatory
-    # identifier must be a hash, can take the forms
-    #   {card: <Pin::Card>}
-    #   {card_token: String<"...">}
-    #   {customer_token: String<"...">}
-    #   {customer: <Pin::Customer>}
-    # eg. {email: 'alex@payaus.com', description: '1 month of PayAus', amount: 19900, currency: 'AUD', ip_address: '203.192.1.172', customer_token: 'asdf'}
-    def self.create(options = {})
-      options[:customer_token] = options.delete(:customer).token unless options[:customer].nil?
-      build_instance_from_response(authenticated_post('/charges', options))
+    attr_accessor :refunds
+
+    class << self
+      # options should be a hash with the following params
+      # email, description, amount, currency, ip_address are mandatory
+      # identifier must be a hash, can take the forms
+      #   {card: <Pin::Card>}
+      #   {card_token: String<"...">}
+      #   {customer_token: String<"...">}
+      #   {customer: <Pin::Customer>}
+      # eg. {email: 'user@example.com', description: 'One month subscription', amount: 19900, currency: 'USD', ip_address: '192.0.0.1', customer_token: 'asdf'}
+      def create(options = {})
+        options[:customer_token] = options.delete(:customer).token unless options[:customer].nil?
+        super(options)
+      end
     end
 
-    def self.all # TODO: pagination
-      build_collection_from_response(authenticated_get('/charges'))
+    # find all refunds for the current Charge object
+    # returns a list of Refunds
+    def refunds
+      Refund.all(token)
     end
 
-    def self.find(token)
-      build_instance_from_response(authenticated_get("/charges/#{token}"))
+    # creates a refund for this Charge
+    # refunds the full amount of the charge by default, provide an amount in cents to override
+    def refund!(amnt = nil)
+      Refund.create(token, amnt)
     end
   end
 end

data/lib/pin-payments/customer.rb

@@ -2,25 +2,19 @@ module Pin
   class Customer < Base
     attr_accessor :email, :created_at, :token, :card
 
-    # email should be a string
-    # card_or_token can be a Pin::Card object
-    # or a card_token (as a string)
-    def self.create(email, card_or_token)
-      options = if card_or_token.respond_to?(:to_hash) # card
-        {card: card_or_token.to_hash}
-      else # token
-        {card_token: card_or_token}
-      end.merge(email: email)
+    class << self
+      # email should be a string
+      # card_or_token can be a Pin::Card object
+      # or a card_token (as a string)
+      def create(email, card_or_token)
+        options = if card_or_token.respond_to?(:to_hash) # card
+          {card: card_or_token.to_hash}
+        else # token
+          {card_token: card_or_token}
+        end.merge(email: email)
 
-      build_instance_from_response(authenticated_post('/customers', options))
-    end
-
-    def self.all # TODO: pagination
-      build_collection_from_response(authenticated_get('/customers'))
-    end
-
-    def self.find(token)
-      build_instance_from_response(authenticated_get("/customers/#{token}"))
+        super(options)
+      end
     end
   end
 end

data/lib/pin-payments/refund.rb

@@ -0,0 +1,40 @@
+module Pin
+  class Refund < Base
+    attr_accessor :token,
+                  :amount, :currency, :charge,
+                  :success, :error_message, :created_at
+
+    class << self
+      # provide a charge object, or charge ID, and it will be refunded
+      # optionally provide an amount in cents, greater than equal to 100, to refund
+      # defaults to the full amount of the charge
+      def create(charge_or_charge_id, amount = nil)
+        raise "`amount` must be greater than or equal to 100" if !amount.nil? && amount < 100
+
+        super({amount: amount}, path_for(charge_or_charge_id))
+      end
+
+      def all(charge_or_charge_id)
+        super(path: path_for(charge_or_charge_id))
+      end
+
+      protected
+      def api_path
+        "charges/%s/refunds"
+      end
+
+      private
+      def path_for(charge_or_charge_id)
+        api_path % parse_charge_id(charge_or_charge_id)
+      end
+
+      def parse_charge_id(charge_or_charge_id)
+        if charge_or_charge_id.respond_to?(:token) # charge
+          charge_or_charge_id.token
+        else # already an ID
+          charge_or_charge_id
+        end
+      end
+    end
+  end
+end

data/lib/pin-payments/response.rb

@@ -0,0 +1,36 @@
+module Pin
+  class CollectionResponse
+    attr_reader :collection, :page_count, :per_page, :page
+
+    def initialize(collection, per_page, page_count, current_page)
+      @collection = collection
+      @page_count = page_count
+      @per_page = per_page
+      @page = current_page
+    end
+
+    def first_page?
+      @page == 1
+    end
+
+    def last_page?
+      @page == @page_count
+    end
+
+    def next_page?
+      @page_count > 1 && !last_page?
+    end
+
+    def previous_page?
+      @page_count > 1 && !first_page?
+    end
+
+    def method_missing(meth, *args, &block)
+      if collection.respond_to?(meth)
+        collection.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/pin-payments.gemspec

@@ -4,8 +4,8 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name        = 'pin-payments'
-  s.version     = '0.0.3'
-  s.date        = '2013-07-26'
+  s.version     = '1.0'
+  s.date        = '2013-08-06'
   s.summary     = "Pin Payments API wrapper"
   s.description = "A wrapper for the Pin Payments (https://pin.net.au/) API"
   s.authors     = ["Alex Ghiculescu"]

data/test/stub_responses/customers.json

@@ -20,6 +20,7 @@
   "pagination": {
     "current": 1,
     "per_page": 25,
+    "pages": 1,
     "count": 1
   }
 }

data/test/stub_responses/new_charge.json

@@ -0,0 +1,26 @@
+{
+  "response": {
+    "token": "ch_lfUYEBK14zotCTykezJkfg",
+    "success": true,
+    "amount": 400,
+    "currency": null,
+    "description": "test charge",
+    "email": "roland@pin.net.au",
+    "ip_address": "203.192.1.172",
+    "created_at": "2012-06-20T03:10:49Z",
+    "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
+  }
+}

data/test/stub_responses/new_customer.json

@@ -0,0 +1,18 @@
+{
+  "response": {
+    "token": "cus_XZg1ULpWaROQCOT5PdwLkQ",
+    "email": "roland@pin.net.au",
+    "created_at": "2012-06-22T06:27:33Z",
+    "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"
+    }
+  }
+}

data/test/stub_responses/new_refund.json

@@ -0,0 +1,12 @@
+{
+  "response": {
+    "token": "rf_ERCQy--Ay6o-NKGiUVcKKA",
+    "success": null,
+    "amount": 400,
+    "currency": "AUD",
+    "charge": "ch_bZ3RhJnIUZ8HhfvH8CCvfA",
+    "created_at": "2012-10-27T13:00:00Z",
+    "error_message": null,
+    "status_message": "Pending"
+  }
+}

data/test/stub_responses/refunds.json

@@ -0,0 +1,19 @@
+{
+  "response": [
+    {
+      "token": "rf_ERCQy--Ay6o-NKGiUVcKKA",
+      "success": null,
+      "amount": 400,
+      "currency": "AUD",
+      "charge": "ch_bZ3RhJnIUZ8HhfvH8CCvfA",
+      "created_at": "2012-10-27T13:00:00Z",
+      "error_message": null,
+      "status_message": "Pending"
+    }
+  ],
+  "pagination": {
+    "current": 1,
+    "per_page": 25,
+    "count": 1
+  }
+}

data/test/test_helper.rb

@@ -11,13 +11,14 @@ module TestHelper
   SECRET_KEY = ENV["PIN_SECRET_KEY"] || "fake_key"
   PIN_ENV = ENV["PIN_ENV"] || :test
 
-  Pin::Base.setup SECRET_KEY, PIN_ENV
+  Pin.setup(secret_key: SECRET_KEY, mode: PIN_ENV)
 
   def get_file(filename)
     File.new(File.dirname(__FILE__) + "/stub_responses/" + filename)
   end
   
-  def get_record_json(type, token = nil)
+  def get_record_json(type, new_record = false, token = nil)
+    type = "new_#{type.singularize}" if new_record
     if token.nil?
       get_file("#{type}.json")
     else
@@ -27,24 +28,20 @@ module TestHelper
   
   def mock_get(model_name, do_each = true)
     stub_request(:get, /#{model_name.downcase}$/).to_return(body: get_record_json(model_name.downcase.pluralize), status: 200, headers: {'Content-Type' => 'application/json; charset=utf-8'})
+    stub_request(:get, /#{model_name.downcase}\?page=[0-9]$/).to_return(body: get_record_json(model_name.downcase.pluralize), status: 200, headers: {'Content-Type' => 'application/json; charset=utf-8'})
     if do_each
       Pin.const_get(model_name.singularize).all.each do |record|
-        stub_request(:get, /#{model_name.downcase}\/#{record.token}$/).to_return(body: get_record_json(model_name.downcase.singularize, record.token), status: 200, headers: {'Content-Type' => 'application/json; charset=utf-8'})
+        stub_request(:get, /#{model_name.downcase}\/#{record.token}$/).to_return(body: get_record_json(model_name.downcase.singularize, false, record.token), status: 200, headers: {'Content-Type' => 'application/json; charset=utf-8'})
       end
     end
   end
 
-  def mock_post(model_name, do_each = true)
-    stub_request(:post, /#{model_name.downcase}$/).to_return(body: get_record_json(model_name.downcase.pluralize), status: 201, headers: {'Content-Type' => 'application/json; charset=utf-8'})
-    if do_each
-      Pin.const_get(model_name.singularize).all.each do |record|
-        stub_request(:post, /#{model_name.downcase}\/#{record.token}$/).to_return(body: get_record_json(model_name.downcase.singularize, record.token), status: 201, headers: {'Content-Type' => 'application/json; charset=utf-8'})
-      end
-    end
+  def mock_post(model_name)
+    stub_request(:post, /#{model_name.downcase}$/).to_return(body: get_record_json(model_name.downcase.pluralize, true), status: 201, headers: {'Content-Type' => 'application/json; charset=utf-8'})
   end
 
-  def mock_api(model_name)
-    mock_get(model_name)
+  def mock_api(model_name, do_each = true)
+    mock_get(model_name, do_each)
     mock_post(model_name)
   end
 end

data/test/unit/cards_test.rb

@@ -4,7 +4,7 @@ class CardsTest < Test::Unit::TestCase
   include TestHelper
   
   def setup
-    mock_post('Cards', false)
+    mock_post('Cards')
   end
 
   def test_create

data/test/unit/charges_test.rb

@@ -4,7 +4,7 @@ class ChargesTest < Test::Unit::TestCase
   include TestHelper
   
   def setup
-    mock_post('Cards', false)
+    mock_post('Cards')
     mock_api('Charges')
     mock_api('Customers')
   end

data/test/unit/customers_test.rb

@@ -5,7 +5,7 @@ class CustomersTest < Test::Unit::TestCase
   
   def setup
     mock_api('Customers')
-    mock_post('Cards', false)
+    mock_post('Cards')
   end
 
   def test_get_all # for some reason `test "get all" do` wasn't working...
@@ -17,6 +17,15 @@ class CustomersTest < Test::Unit::TestCase
     assert_not_nil customer
   end
 
+  def test_get_pages_of_customers
+    customers = Pin::Customer.all(page: 1)
+    assert_equal 1, customers.page
+
+    # TODO: mock this
+    #customers = Pin::Customer.all(page: 2)
+    #assert_equal 2, customers.page
+  end
+
   def test_create_customer_with_card
     card = Pin::Card.new number: '5520000000000000', expiry_month: '12', 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'
 

data/test/unit/refunds_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class RefundsTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    mock_api('Charges')
+    mock_api('Refunds', false)
+  end
+
+  def test_get_all_with_charge
+    charge = Pin::Charge.first
+
+    refunds = Pin::Refund.all(charge)
+    assert_equal 1, refunds.length
+  end
+
+  def test_get_all_with_charge_token
+    charge = Pin::Charge.first
+
+    refunds = Pin::Refund.all(charge.token)
+    assert_equal 1, refunds.length
+  end
+
+  def test_get_refunds_as_charge_method
+    charge = Pin::Charge.first
+
+    refunds = charge.refunds
+    assert_equal 1, refunds.length
+  end
+
+  def test_create_refund
+    charge = Pin::Charge.first
+
+    refund = charge.refund!
+    assert_not_nil refund
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pin-payments
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: '1.0'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-26 00:00:00.000000000 Z
+date: 2013-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -75,16 +75,23 @@ files:
 - lib/pin-payments/card.rb
 - lib/pin-payments/charge.rb
 - lib/pin-payments/customer.rb
+- lib/pin-payments/refund.rb
+- lib/pin-payments/response.rb
 - pin-payments.gemspec
-- test/stub_responses/cards.json
 - test/stub_responses/charges.json
 - test/stub_responses/customers.json
+- test/stub_responses/new_card.json
+- test/stub_responses/new_charge.json
+- test/stub_responses/new_customer.json
+- test/stub_responses/new_refund.json
 - test/stub_responses/records/charge-ch_lfUYEBK14zotCTykezJkfg.json
 - test/stub_responses/records/customer-cus_XZg1ULpWaROQCOT5PdwLkQ.json
+- test/stub_responses/refunds.json
 - test/test_helper.rb
 - test/unit/cards_test.rb
 - test/unit/charges_test.rb
 - test/unit/customers_test.rb
+- test/unit/refunds_test.rb
 homepage: https://github.com/ghiculescu/pin-payments
 licenses:
 - MIT
@@ -111,12 +118,17 @@ signing_key:
 specification_version: 3
 summary: Pin Payments API wrapper
 test_files:
-- test/stub_responses/cards.json
 - test/stub_responses/charges.json
 - test/stub_responses/customers.json
+- test/stub_responses/new_card.json
+- test/stub_responses/new_charge.json
+- test/stub_responses/new_customer.json
+- test/stub_responses/new_refund.json
 - test/stub_responses/records/charge-ch_lfUYEBK14zotCTykezJkfg.json
 - test/stub_responses/records/customer-cus_XZg1ULpWaROQCOT5PdwLkQ.json
+- test/stub_responses/refunds.json
 - test/test_helper.rb
 - test/unit/cards_test.rb
 - test/unit/charges_test.rb
 - test/unit/customers_test.rb
+- test/unit/refunds_test.rb