paybox_direct 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f3f9d965c2389c181f66f32085909188b16c13f
+  data.tar.gz: ba08b3fed53319a6765594f57d021d8035d5ef64
+SHA512:
+  metadata.gz: 1636b4051d042b6ff98ed410c837bcbac6c3f6c0d9e143ad27ff49519bb28818dd358c75cf3acc4e05ed8977bb3849478ca8224016a015da9f7ab402d20e4f5a
+  data.tar.gz: 830bea4f1d63f0cd24fc27ae0cf96274efa3c941d4dee446bca484535497cc6fec2ac1489874ded4101625215e1dee4169b00c764e88a125993b9bf28612b5b6

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright © 2015, Kévin Lesénéchal <kevin.lesenechal@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+
+  3. Neither the name of the copyright holder nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,151 @@
+# Paybox Direct Ruby API #
+
+The `paybox_direct` gem provides a Ruby interface to the French payment platform
+**Paybox** and more specifically their **Paybox Direct** and **Paybox Direct
+Plus** products. If you plan to use **Paybox Systems**, this gem won't be of any
+help.
+
+## Installation ##
+
+Put this in your `Gemfile`:
+
+    gem 'paybox_direct'
+
+To include all the necessary classes, do:
+
+    require 'paybox_direct'
+
+## Configuration ##
+
+Use `PayboxDirect.config` to configure the default settings of the API like your
+Paybox credentials. Example:
+
+    PayboxDirect.config.site = 410555 # Your site number
+
+The available configuration variables are:
+
+ * `site`: (Integer) Your site number, see your Paybox contract;
+ * `rank`: (Integer) Your rank number, see your Paybox contract;
+ * `login`: (String) Your login, see your Paybox contract;
+ * `password`: (String) Your password, see your Paybox contract;
+ * `is_prod`: (Boolean) Set to false to use the Paybox test server;
+ * `ref_prefix`: (String) A prefix to all references including subscriber IDs;
+ * `version`: (Integer) The protocol version, `103` for *Paybox Direct*, `104` for *Paybox Direct Plus*;
+ * `activity`: (Integer/nil) The activity code (`ACTIVITE`), see Paybox documentation;
+ * `bank`: (Integer/nil) The `ACQUEREUR` variable, let `nil` if you don't have special requirements.
+
+## Usage ##
+
+### Authorization only ###
+
+This call will make an authorization without debit:
+
+    req = PayboxDirect.authorize(
+      ref:       "my_app_reference",
+      amount:    38.29,
+      currency:  :EUR,
+      cc_number: "4012-0010-3844-3335", # you may omit the dashes
+      cc_expire: Date.new(2016, 10, 1), # the day of month doesn't matter
+      cc_cvv:    "123"
+    )
+    req.response[:request_id]     # => The Paybox request ID (NUMAPPEL)
+    req.response[:transaction_id] # => The Paybox transaction ID (NUMTRANS)
+    req.response[:authorization]  # => The authorization number, `nil` in dev
+
+In case of failure, this will raise a `PayboxDirect::AuthorizationError`
+exception. This exception contains two methods: `code` for the numeric error
+code (see documentation) and `comment` for a brief error comment (in French)
+returned by Paybox.
+
+### Immediate debit ###
+
+To immediately debit a credit card, use the exact same call than before, just
+call the `debit` method instead. This may raise a `DebitError` which inherits
+`AuthorizationError`.
+
+### Debit on a prior authorization only ###
+
+After an authorization only, you can make this call to proceed to debit:
+
+    PayboxDirect.debit_authorization(
+      amount:         38.29,      # This may be lower than the authorization
+      currency:       :EUR,
+      request_id:     my_req_id,  # The request ID returned from authorization
+      transaction_id: my_trans_id # The transaction ID returned from authorization
+    )
+
+Will raise `DebitError` in case of failure.
+
+### Subscribers and wallet codes ###
+
+With *Paybox Direct Plus* you can register subscribers for future operations and
+not having to store their credit card credentials. To create a subscriber, you
+must make an authorization and/or debit and provide the `subscriber` parameter.
+This parameter will contain a unique subscriber ID.
+
+When creating a subscriber, the request will return a **wallet code** which is a
+string representing the card number will you will pass to future calls on this
+subscriber.
+
+Creation:
+
+    req = PayboxDirect.authorize(
+      ref:       "my_app_reference",
+      amount:    38.29,
+      currency:  :EUR,
+      cc_number: "4012-0010-3844-3335",
+      cc_expire: Date.new(2016, 10, 1),
+      cc_cvv:    "123",
+      subscriber: "my_sub_id" # This will create this subscriber
+    )
+    req.response[:wallet] # => Contains the wallet code to store in DB
+
+To proceed to an authorization or debit on a previously created subscriber,
+simply replace the `cc_number` argument with `wallet` and provide the subscriber
+ID. Example:
+
+    PayboxDirect.debit(
+      ref:        "my_app_reference",
+      amount:     38.29,
+      currency:   :EUR,
+      wallet:     my_wallet_code, # The wallet we got on the subscriber's creation
+      cc_expire:  Date.new(2016, 10, 1),
+      cc_cvv:     "123",
+      subscriber: "my_sub_id" # The subscriber ID previously created
+    )
+
+### Refund a payment ###
+
+If you want to refund a user, use the `refund` method with:
+
+ * `amount`;
+ * `currency`;
+ * `request_id`;
+ * `transaction_id`.
+
+It may raise `RefundError`, which is clearly possible if the debit you want to
+refund wasn't sent to bank yet. The `refund` operation can only apply to
+definitive payments. Therefor, you should try to **cancel** the operation (see
+below) before refunding.
+
+### Cancel an operation ###
+
+Almost all payment operations can be cancelled before they are transmitted to
+the bank and become definitive. Use the `cancel` with these options:
+
+ * `amount`;
+ * `currency`;
+ * `ref`;
+ * `cc_number` or `wallet`;
+ * `cc_expire`;
+ * `cc_cvv`;
+ * `subscriber` (optional, only if on a subscriber);
+ * `request_id`;
+ * `transaction_id`.
+
+In case of failures, it raises `CancelError`.
+
+### Credits ###
+
+You can credit a user using the `credit` method, this works the same than debits
+including with subscribers. It may raise `CreditError`.

data/lib/paybox_direct.rb

@@ -0,0 +1,387 @@
+# Copyright © 2015, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'ostruct'
+require 'net/http'
+
+class PayboxDirect
+  DEV_URL           = 'https://preprod-ppps.paybox.com/PPPS.php'
+  PROD_URL          = 'https://ppps.paybox.com/PPPS.php'
+  PROD_FALLBACK_URL = 'https://ppps1.paybox.com/PPPS.php'
+
+  CURRENCIES = {
+    :AUD => 36,
+    :CAD => 124,
+    :CHF => 756,
+    :DKK => 208,
+    :EUR => 978,
+    :GBP => 826,
+    :HKD => 344,
+    :JPY => 392,
+    :USD => 840
+  }
+
+  @@config = OpenStruct.new({
+    site:       nil,  # Your site number, see your Paybox contract
+    rank:       nil,  # Your rank number, see your Paybox contract
+    login:      nil,  # Your login, see your Paybox contract
+    password:   nil,  # Your password, see your Paybox contract
+    is_prod:    true, # Set to false to use the Paybox test server
+    ref_prefix: '',   # A prefix to all references including subscriber IDs
+    version:    104,  # The protocol version, 103 for Paybox Direct, 104 for Paybox Direct Plus
+    activity:   nil,  # The activity code (ACTIVITE), see Paybox documentation
+    bank:       nil   # The ACQUEREUR variable, let nil if you don't have special requirements
+  })
+
+  def self.config
+    @@config
+  end
+
+  # Executes an authorization with or without debit.
+  #
+  # == Options:
+  # * amount:     The decimal amount, e.g. 49.9 for €49.90 (or other currency)
+  # * currency:   The currency code, e.g. :EUR
+  # * ref:        The application reference for this authorization
+  # * cc_number:  The credit card number, e.g. "1234123412341234" (if not subscribed)
+  # * wallet:     The wallet number (if subscribed)
+  # * cc_expire:  The credit card expiration date, e.g. Date.new(2015, 10, 1)
+  # * cc_cvv:     The credit card CVV, e.g. "123"
+  # * subscriber: (optional) A subscriber ID
+  # * debit:      (Bool) if true, will debit (default false)
+  #
+  # If a subscriber ID is provided:
+  # * and `wallet` is provided, will execute a #51 operation (#53 if debit);
+  # * and `wallet` is NOT provided, will execute a #56 operation (then #2 if debit);
+  # otherwise, will execute a #1 operation (#3 if debit).
+  #
+  # == Returns: (PayboxDirect::Request)
+  # The Paybox request with these response variables:
+  # * request_id:     The Paybox request ID (NUMAPPEL)
+  # * transaction_id: The Paybox transaction ID (NUMTRANS)
+  # * wallet:         (if new subscription) The created wallet code (PORTEUR)
+  #
+  # == Raises:
+  # * PayboxDirect::AuthorizationError, if authorization fails
+  # * PayboxDirect::ServerUnavailableError, if Paybox server is unavailable
+  def self.authorize(opts)
+    raise ArgumentError, "Expecting hash" unless opts.is_a? Hash
+    raise ArgumentError, "Expecting `amount` option" unless opts.has_key? :amount
+    raise ArgumentError, "Expecting `currency` option" unless opts.has_key? :currency
+    raise ArgumentError, "Expecting `ref` option" unless opts.has_key? :ref
+    raise ArgumentError, "Expecting `cc_expire` option" unless opts.has_key? :cc_expire
+    raise ArgumentError, "Expecting `cc_cvv` option" unless opts.has_key? :cc_cvv
+    raise ArgumentError, "amount: Expecting Numeric" unless opts[:amount].is_a? Numeric
+    raise ArgumentError, "currency: Not supported" unless CURRENCIES.has_key? opts[:currency]
+    raise ArgumentError, "cc_expire: Expecting Date" unless opts[:cc_expire].is_a? Date
+    opts[:debit] = false if !opts.has_key? :debit
+
+    if opts.has_key? :subscriber
+      if opts.has_key? :wallet
+        raise ArgumentError, "cc_number: Unexpected when `wallet` provided" if opts.has_key? :cc_number
+        op_code = opts[:debit] ? 53 : 51
+      else
+        raise ArgumentError, "Expecting `cc_number` option" unless opts.has_key? :cc_number
+        op_code = 56 # Paybox can't create a new subscriber with immediate debit
+      end
+    else
+      raise ArgumentError, "Expecting `cc_number` option" unless opts.has_key? :cc_number
+      raise ArgumentError, "Unexpected `wallet` option" if opts.has_key? :wallet
+      op_code = opts[:debit] ? 3 : 1
+    end
+
+    vars = {
+      "TYPE"      => op_code.to_s.rjust(5, "0"),
+      "REFERENCE" => @@config.ref_prefix + opts[:ref],
+      "MONTANT"   => (opts[:amount].round(2) * 100).round.to_s.rjust(10, "0"),
+      "DEVISE"    => CURRENCIES[opts[:currency]].to_s.rjust(3, "0"),
+      "PORTEUR"   => opts.has_key?(:wallet) ? opts[:wallet] : opts[:cc_number].gsub(/[ -.]/, ""),
+      "DATEVAL"   => opts[:cc_expire].strftime("%m%y"),
+      "CVV"       => opts[:cc_cvv]
+    }
+    if opts.has_key? :subscriber
+      vars["REFABONNE"] = @@config.ref_prefix + opts[:subscriber]
+    end
+    req = Request.new(vars)
+    req.execute!
+
+    if req.failed?
+      raise AuthorizationError.new(req.error_code, req.error_comment)
+    end
+    req.response = {
+      request_id:     req.fields["NUMAPPEL"].to_i,
+      transaction_id: req.fields["NUMTRANS"].to_i,
+      authorization:  req.fields["AUTORISATION"] == "XXXXXX" ? nil : req.fields["AUTORISATION"].to_i
+    }
+    if op_code == 56
+      req.response[:wallet] = req.fields["PORTEUR"]
+
+      # We now execute debit after authorization-only operation #56
+      if opts[:debit]
+        sleep 1 # Paybox recommends to wait a few seconds between the authorization and the debit
+        debit_authorization(
+          amount:         opts[:amount],
+          currency:       opts[:currency],
+          request_id:     req.response[:request_id],
+          transaction_id: req.response[:transaction_id]
+        )
+      end
+    end
+    return req
+  end
+
+  # Executes a direct debit, without prior authorization.
+  #
+  # Calls #authorize with { debit: true }.
+  def self.debit(opts)
+    opts[:debit] = true
+    return authorize(opts)
+  end
+
+  # Executes a debit on a prior authorization.
+  #
+  # == Options:
+  # * amount:         The decimal amount, e.g. 49.9 for €49.90 (or other currency)
+  # * currency:       The currency code, e.g. :EUR
+  # * request_id:     The Paybox request ID (NUMAPPEL)
+  # * transaction_id: The Paybox transaction ID (NUMTRANS)
+  #
+  # This will execute a #2 operation.
+  #
+  # == Returns: (PayboxDirect::Request)
+  # The Paybox request.
+  #
+  # == Raises:
+  # * PayboxDirect::DebitError, if debit fails
+  # * PayboxDirect::ServerUnavailableError, if Paybox server is unavailable
+  def self.debit_authorization(opts)
+    raise ArgumentError, "Expecting hash" unless opts.is_a? Hash
+    raise ArgumentError, "Expecting `amount` option" unless opts.has_key? :amount
+    raise ArgumentError, "Expecting `currency` option" unless opts.has_key? :currency
+    raise ArgumentError, "Expecting `request_id` option" unless opts.has_key? :request_id
+    raise ArgumentError, "Expecting `transaction_id` option" unless opts.has_key? :transaction_id
+    raise ArgumentError, "amount: Expecting Numeric" unless opts[:amount].is_a? Numeric
+    raise ArgumentError, "currency: Not supported" unless CURRENCIES.has_key? opts[:currency]
+    raise ArgumentError, "request_id: Expecting Fixnum" unless opts[:request_id].is_a? Fixnum
+    raise ArgumentError, "transaction_id: Expecting Fixnum" unless opts[:transaction_id].is_a? Fixnum
+
+    req = Request.new({
+      "TYPE"     => "00002",
+      "MONTANT"  => (opts[:amount].round(2) * 100).round.to_s.rjust(10, "0"),
+      "DEVISE"   => CURRENCIES[opts[:currency]].to_s.rjust(3, "0"),
+      "NUMAPPEL" => opts[:request_id].to_s.rjust(10, "0"),
+      "NUMTRANS" => opts[:transaction_id].to_s.rjust(10, "0")
+    })
+    req.execute!
+
+    if req.failed?
+      raise DebitError.new(req.error_code, req.error_comment)
+    end
+    return req
+  end
+
+  # Cancels an operation if possible.
+  #
+  # == Options:
+  # * amount:     The decimal amount, e.g. 49.9 for €49.90 (or other currency)
+  # * currency:   The currency code, e.g. :EUR
+  # * ref:        The credit application reference
+  # * wallet:     The wallet number (if subscribed)
+  # * cc_expire:  The credit card expiration date, e.g. Date.new(2015, 10, 1) (if subscribed)
+  # * cc_cvv:     The credit card CVV, e.g. "123"
+  # * subscriber: (optional) A subscriber ID
+  # * request_id:     The request ID (NUMAPPEL)
+  # * transaction_id: The transaction ID (NUMTRANS)
+  #
+  # This will execute a #55 operation if a subscriber is specified, otherwise
+  # a #5 operation.
+  #
+  # == Returns: (PayboxDirect::Request)
+  # The Paybox request.
+  #
+  # == Raises:
+  # * PayboxDirect::CancelError, if cancellation fails
+  # * PayboxDirect::ServerUnavailableError, if Paybox server is unavailable
+  def self.cancel(opts)
+    raise ArgumentError, "Expecting hash" unless opts.is_a? Hash
+    raise ArgumentError, "Expecting `amount` option" unless opts.has_key? :amount
+    raise ArgumentError, "Expecting `currency` option" unless opts.has_key? :currency
+    raise ArgumentError, "Expecting `ref` option" unless opts.has_key? :ref
+    raise ArgumentError, "Expecting `cc_cvv` option" unless opts.has_key? :cc_cvv
+    raise ArgumentError, "Expecting `request_id` option" unless opts.has_key? :request_id
+    raise ArgumentError, "Expecting `transaction_id` option" unless opts.has_key? :transaction_id
+    raise ArgumentError, "amount: Expecting Numeric" unless opts[:amount].is_a? Numeric
+    raise ArgumentError, "currency: Not supported" unless CURRENCIES.has_key? opts[:currency]
+    raise ArgumentError, "cc_expire: Expecting Date" unless opts[:cc_expire].is_a? Date
+    raise ArgumentError, "request_id: Expecting Numeric" unless opts[:request_id].is_a? Numeric
+    raise ArgumentError, "transaction_id: Expecting Numeric" unless opts[:transaction_id].is_a? Numeric
+
+    if opts.has_key? :subscriber
+      raise ArgumentError, "Expecting `wallet` option" unless opts.has_key? :wallet
+      raise ArgumentError, "Expecting `cc_expire` option" unless opts.has_key? :cc_expire
+      op_code = 55
+    else
+      raise ArgumentError, "Unexpected `wallet` option" if opts.has_key? :wallet
+      op_code = 5
+    end
+
+    vars = {
+      "TYPE"      => op_code.to_s.rjust(5, "0"),
+      "REFERENCE" => @@config.ref_prefix + opts[:ref],
+      "MONTANT"   => (opts[:amount].round(2) * 100).round.to_s.rjust(10, "0"),
+      "DEVISE"    => CURRENCIES[opts[:currency]].to_s.rjust(3, "0"),
+      "DATEVAL"   => opts[:cc_expire].strftime("%m%y"),
+      "CVV"       => opts[:cc_cvv],
+      "NUMAPPEL"  => opts[:request_id].to_s.rjust(10, "0"),
+      "NUMTRANS"  => opts[:transaction_id].to_s.rjust(10, "0")
+    }
+    if opts.has_key? :subscriber
+      vars["PORTEUR"]   = opts[:wallet]
+      vars["REFABONNE"] = @@config.ref_prefix + opts[:subscriber]
+    end
+    req = Request.new(vars)
+    req.execute!
+
+    if req.failed?
+      raise CancelError.new(req.error_code, req.error_comment)
+    end
+    return req
+  end
+
+  # Executes a refund operation.
+  #
+  # == Options:
+  # * amount:         The decimal amount, e.g. 49.9 for €49.90 (or other currency)
+  # * currency:       The currency code, e.g. :EUR
+  # * request_id:     The request ID (NUMAPPEL)
+  # * transaction_id: The transaction ID (NUMTRANS)
+  #
+  # This will execute a #14 operation.
+  #
+  # == Returns: (PayboxDirect::Request)
+  # The Paybox request.
+  #
+  # == Raises:
+  # * PayboxDirect::RefundError, if cancellation fails
+  # * PayboxDirect::ServerUnavailableError, if Paybox server is unavailable
+  def self.refund(opts)
+    raise ArgumentError, "Expecting hash" unless opts.is_a? Hash
+    raise ArgumentError, "Expecting `amount` option" unless opts.has_key? :amount
+    raise ArgumentError, "Expecting `currency` option" unless opts.has_key? :currency
+    raise ArgumentError, "Expecting `request_id` option" unless opts.has_key? :request_id
+    raise ArgumentError, "Expecting `transaction_id` option" unless opts.has_key? :transaction_id
+    raise ArgumentError, "amount: Expecting Numeric" unless opts[:amount].is_a? Numeric
+    raise ArgumentError, "currency: Not supported" unless CURRENCIES.has_key? opts[:currency]
+    raise ArgumentError, "request_id: Expecting Numeric" unless opts[:request_id].is_a? Numeric
+    raise ArgumentError, "transaction_id: Expecting Numeric" unless opts[:transaction_id].is_a? Numeric
+
+    req = Request.new({
+      "TYPE"     => "00014",
+      "MONTANT"  => (opts[:amount].round(2) * 100).round.to_s.rjust(10, "0"),
+      "DEVISE"   => CURRENCIES[opts[:currency]].to_s.rjust(3, "0"),
+      "NUMAPPEL" => opts[:request_id].to_s.rjust(10, "0"),
+      "NUMTRANS" => opts[:transaction_id].to_s.rjust(10, "0")
+    })
+    req.execute!
+
+    if req.failed?
+      raise RefundError.new(req.error_code, req.error_comment)
+    end
+    return req
+  end
+
+  # Executes a credit operation.
+  #
+  # == Options:
+  # * amount:     The decimal amount, e.g. 49.9 for €49.90 (or other currency)
+  # * currency:   The currency code, e.g. :EUR
+  # * ref:        The credit application reference
+  # * cc_number:  The credit card number, e.g. "1234123412341234" (if not subscribed)
+  # * wallet:     The wallet number (if subscribed)
+  # * cc_expire:  The credit card expiration date, e.g. Date.new(2015, 10, 1)
+  # * cc_cvv:     The credit card CVV, e.g. "123"
+  # * subscriber: (optional) A subscriber ID
+  #
+  # This will execute a #54 operation if a subscriber is specified, otherwise
+  # a #4 operation.
+  #
+  # == Returns: (PayboxDirect::Request)
+  # The Paybox request.
+  #
+  # == Raises:
+  # * PayboxDirect::CreditError, if credit fails
+  # * PayboxDirect::ServerUnavailableError, if Paybox server is unavailable
+  def self.credit(opts)
+    raise ArgumentError, "Expecting hash" unless opts.is_a? Hash
+    raise ArgumentError, "Expecting `amount` option" unless opts.has_key? :amount
+    raise ArgumentError, "Expecting `currency` option" unless opts.has_key? :currency
+    raise ArgumentError, "Expecting `ref` option" unless opts.has_key? :ref
+    raise ArgumentError, "Expecting `cc_expire` option" unless opts.has_key? :cc_expire
+    raise ArgumentError, "Expecting `cc_cvv` option" unless opts.has_key? :cc_cvv
+    raise ArgumentError, "amount: Expecting Numeric" unless opts[:amount].is_a? Numeric
+    raise ArgumentError, "currency: Not supported" unless CURRENCIES.has_key? opts[:currency]
+    raise ArgumentError, "cc_expire: Expecting Date" unless opts[:cc_expire].is_a? Date
+
+    if opts.has_key? :subscriber
+      raise ArgumentError, "Expecting `wallet` option" unless opts.has_key? :wallet
+      raise ArgumentError, "cc_number: Unexpected when `wallet` provided" if opts.has_key? :cc_number
+      op_code = 54
+    else
+      raise ArgumentError, "Expecting `cc_number` option" unless opts.has_key? :cc_number
+      raise ArgumentError, "Unexpected `wallet` option" if opts.has_key? :wallet
+      op_code = 4
+    end
+
+    vars = {
+      "TYPE"      => op_code.to_s.rjust(5, "0"),
+      "REFERENCE" => @@config.ref_prefix + opts[:ref],
+      "MONTANT"   => (opts[:amount].round(2) * 100).round.to_s.rjust(10, "0"),
+      "DEVISE"    => CURRENCIES[opts[:currency]].to_s.rjust(3, "0"),
+      "PORTEUR"   => opts.has_key?(:wallet) ? opts[:wallet] : opts[:cc_number].gsub(/[ -.]/, ""),
+      "DATEVAL"   => opts[:cc_expire].strftime("%m%y"),
+      "CVV"       => opts[:cc_cvv]
+    }
+    if opts.has_key? :subscriber
+      vars["REFABONNE"] = @@config.ref_prefix + opts[:subscriber]
+    end
+    req = Request.new(vars)
+    req.execute!
+
+    if req.failed?
+      raise CreditError.new(req.error_code, req.error_comment)
+    end
+    return req
+  end
+
+  # Deletes a subscriber per ID.
+  #
+  # == Arguments:
+  # * id: The subscriber ID (REFABONNE).
+  #
+  # This will execute a #58 operation.
+  #
+  # == Returns: (PayboxDirect::Request)
+  # The Paybox request.
+  #
+  # == Raises:
+  # * PayboxDirect::DeleteSubscriberError, if deletion fails
+  # * PayboxDirect::ServerUnavailableError, if Paybox server is unavailable
+  def self.delete_subscriber(id)
+    raise ArgumentError, "id: Expecting String" unless id.is_a? String
+
+    req = Request.new({
+      "TYPE"      => "00058",
+      "REFABONNE" => @@config.ref_prefix + id
+    })
+    req.execute!
+    if req.failed?
+      raise DeleteSubscriberError.new(req.error_code, req.error_comment)
+    end
+    return req
+  end
+end
+
+require 'paybox_direct/request'
+require 'paybox_direct/exceptions'

data/spec/paybox_direct_spec.rb

@@ -0,0 +1,378 @@
+# Copyright © 2015, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'paybox_direct'
+require 'ostruct'
+
+RSpec.describe PayboxDirect do
+  before do
+    PayboxDirect.config.site       = SITE
+    PayboxDirect.config.rank       = RANK
+    PayboxDirect.config.login      = LOGIN
+    PayboxDirect.config.password   = PASSWORD
+    PayboxDirect.config.ref_prefix = REF_PREFIX
+    PayboxDirect.config.activity   = ENV.key?("PB_ACTIVITY") ? ENV["PB_ACTIVITY"].to_i : nil
+    PayboxDirect.config.bank       = ENV.key?("PB_BANK") ? ENV["PB_BANK"] : nil
+    PayboxDirect.config.is_prod    = false
+  end
+
+  context "authorization and debit" do
+    it "should make a auth-only without subscription" do
+      stub_response "CODEREPONSE=00000&COMMENTAIRE=&NUMAPPEL=0000111111&NUMTRANS=0002222222&AUTORISATION=444444" if !DO_CALLS
+
+      req = PayboxDirect.authorize(
+        ref:       "auth_only",
+        amount:    14.29,
+        currency:  :EUR,
+        cc_number: CC_NUMBER,
+        cc_expire: CC_EXPIRE,
+        cc_cvv:    CC_CVV
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00001",
+        "REFERENCE" => REF_PREFIX + "auth_only",
+        "MONTANT"   => "0000001429",
+        "DEVISE"    => "978",
+        "PORTEUR"   => CC_NUMBER.gsub("-", ""),
+        "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+        "CVV"       => CC_CVV
+      })
+
+      if DO_CALLS
+        expect(req.response[:request_id]).to be_a Fixnum
+        expect(req.response[:transaction_id]).to be_a Fixnum
+        expect(req.response[:authorization]).to be_nil
+      else
+        expect(req.response[:request_id]).to eq 111111
+        expect(req.response[:transaction_id]).to eq 2222222
+        expect(req.response[:authorization]).to eq 444444
+      end
+    end
+
+    it "should make a auth-only and create a subscriber" do
+      stub_response "CODEREPONSE=00000&COMMENTAIRE=&NUMAPPEL=0000111111&NUMTRANS=0002222222&AUTORISATION=444444&PORTEUR=my_wallet_code" if !DO_CALLS
+
+      req = PayboxDirect.authorize(
+        ref:        "auth_only_new_subscriber",
+        amount:     25,
+        currency:   :EUR,
+        cc_number:  CC_NUMBER,
+        cc_expire:  CC_EXPIRE,
+        cc_cvv:     CC_CVV,
+        subscriber: "my_sub_id"
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00056",
+        "REFERENCE" => REF_PREFIX + "auth_only_new_subscriber",
+        "MONTANT"   => "0000002500",
+        "DEVISE"    => "978",
+        "PORTEUR"   => CC_NUMBER.gsub("-", ""),
+        "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+        "CVV"       => CC_CVV,
+        "REFABONNE" => REF_PREFIX + "my_sub_id"
+      })
+
+      if DO_CALLS
+        expect(req.response[:request_id]).to be_a Fixnum
+        expect(req.response[:transaction_id]).to be_a Fixnum
+        expect(req.response[:authorization]).to be_nil
+        expect(req.response[:wallet]).to eq "CMDLpStLLLs"
+      else
+        expect(req.response[:request_id]).to eq 111111
+        expect(req.response[:transaction_id]).to eq 2222222
+        expect(req.response[:authorization]).to eq 444444
+        expect(req.response[:wallet]).to eq "my_wallet_code"
+      end
+    end
+
+    it "should make a auth-only on a subscriber" do
+      stub_response "CODEREPONSE=00000&COMMENTAIRE=&NUMAPPEL=0000111111&NUMTRANS=0002222222&AUTORISATION=444444" if !DO_CALLS
+
+      if DO_CALLS
+        req = PayboxDirect.authorize(
+          ref:        "auth_only_subscriber_create",
+          amount:     1,
+          currency:   :EUR,
+          cc_number:  CC_NUMBER,
+          cc_expire:  CC_EXPIRE,
+          cc_cvv:     CC_CVV,
+          subscriber: "my_sub_id2"
+        )
+        wallet = req.response[:wallet]
+      else
+        wallet = "my_wallet_code"
+      end
+
+      req = PayboxDirect.authorize(
+        ref:        "auth_only_subscriber",
+        amount:     25,
+        currency:   :EUR,
+        wallet:     wallet,
+        cc_expire:  CC_EXPIRE,
+        cc_cvv:     CC_CVV,
+        subscriber: "my_sub_id2"
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00051",
+        "REFERENCE" => REF_PREFIX + "auth_only_subscriber",
+        "MONTANT"   => "0000002500",
+        "DEVISE"    => "978",
+        "PORTEUR"   => wallet,
+        "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+        "CVV"       => CC_CVV,
+        "REFABONNE" => REF_PREFIX + "my_sub_id2"
+      })
+
+      if DO_CALLS
+        expect(req.response[:request_id]).to be_a Fixnum
+        expect(req.response[:transaction_id]).to be_a Fixnum
+        expect(req.response[:authorization]).to be_nil
+      else
+        expect(req.response[:request_id]).to eq 111111
+        expect(req.response[:transaction_id]).to eq 2222222
+        expect(req.response[:authorization]).to eq 444444
+      end
+    end
+
+    it "should make a debit without subscription" do
+      stub_response "CODEREPONSE=00000&COMMENTAIRE=&NUMAPPEL=0000111111&NUMTRANS=0002222222&AUTORISATION=444444" if !DO_CALLS
+
+      req = PayboxDirect.debit(
+        ref:       "debit",
+        amount:    50.3,
+        currency:  :EUR,
+        cc_number: CC_NUMBER,
+        cc_expire: CC_EXPIRE,
+        cc_cvv:    CC_CVV
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00003",
+        "REFERENCE" => REF_PREFIX + "debit",
+        "MONTANT"   => "0000005030",
+        "DEVISE"    => "978",
+        "PORTEUR"   => CC_NUMBER.gsub("-", ""),
+        "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+        "CVV"       => CC_CVV
+      })
+
+      if DO_CALLS
+        expect(req.response[:request_id]).to be_a Fixnum
+        expect(req.response[:transaction_id]).to be_a Fixnum
+        expect(req.response[:authorization]).to be_nil
+      else
+        expect(req.response[:request_id]).to eq 111111
+        expect(req.response[:transaction_id]).to eq 2222222
+        expect(req.response[:authorization]).to eq 444444
+      end
+    end
+
+    it "should make a debit and create a subscriber" do
+      if !DO_CALLS
+        allow_any_instance_of(PayboxDirect::Request).to receive(:run_http_post!) { |req|
+          if req.vars["TYPE"] == "00056"
+            OpenStruct.new({
+              code: "200",
+              body: "CODEREPONSE=00000&COMMENTAIRE=&NUMAPPEL=0000111111&NUMTRANS=0002222222&AUTORISATION=444444&PORTEUR=my_wallet_code"
+            })
+          else
+            OpenStruct.new({
+              code: "200",
+              body: "CODEREPONSE=00000&COMMENTAIRE="
+            })
+          end
+        }
+      end
+
+      expect(PayboxDirect).to receive(:debit_authorization).with(
+        amount:         50.3,
+        currency:       :EUR,
+        request_id:     DO_CALLS ? be_a(Fixnum) : 111111,
+        transaction_id: DO_CALLS ? be_a(Fixnum) : 2222222
+      ).and_call_original
+
+      req = PayboxDirect.debit(
+        ref:        "debit_new_subscriber",
+        amount:     50.3,
+        currency:   :EUR,
+        cc_number:  CC_NUMBER,
+        cc_expire:  CC_EXPIRE,
+        cc_cvv:     CC_CVV,
+        subscriber: "my_sub_id3"
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00056",
+        "REFERENCE" => REF_PREFIX + "debit_new_subscriber",
+        "MONTANT"   => "0000005030",
+        "DEVISE"    => "978",
+        "PORTEUR"   => CC_NUMBER.gsub("-", ""),
+        "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+        "CVV"       => CC_CVV,
+        "REFABONNE" => REF_PREFIX + "my_sub_id3"
+      })
+
+      if DO_CALLS
+        expect(req.response[:request_id]).to be_a Fixnum
+        expect(req.response[:transaction_id]).to be_a Fixnum
+        expect(req.response[:authorization]).to be_nil
+        expect(req.response[:wallet]).to eq "CMDLpStLLLs"
+      else
+        expect(req.response[:request_id]).to eq 111111
+        expect(req.response[:transaction_id]).to eq 2222222
+        expect(req.response[:authorization]).to eq 444444
+        expect(req.response[:wallet]).to eq "my_wallet_code"
+      end
+    end
+
+    it "should make a debit on a subscriber" do
+      stub_response "CODEREPONSE=00000&COMMENTAIRE=&NUMAPPEL=0000111111&NUMTRANS=0002222222&AUTORISATION=444444" if !DO_CALLS
+
+      if DO_CALLS
+        req = PayboxDirect.authorize(
+          ref:        "debit_subscriber_create",
+          amount:     1,
+          currency:   :EUR,
+          cc_number:  CC_NUMBER,
+          cc_expire:  CC_EXPIRE,
+          cc_cvv:     CC_CVV,
+          subscriber: "my_sub_id4"
+        )
+        wallet = req.response[:wallet]
+      else
+        wallet = "my_wallet_code"
+      end
+
+      req = PayboxDirect.debit(
+        ref:        "debit_subscriber",
+        amount:     25,
+        currency:   :EUR,
+        wallet:     wallet,
+        cc_expire:  CC_EXPIRE,
+        cc_cvv:     CC_CVV,
+        subscriber: "my_sub_id4"
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00053",
+        "REFERENCE" => REF_PREFIX + "debit_subscriber",
+        "MONTANT"   => "0000002500",
+        "DEVISE"    => "978",
+        "PORTEUR"   => wallet,
+        "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+        "CVV"       => CC_CVV,
+        "REFABONNE" => REF_PREFIX + "my_sub_id4"
+      })
+
+      if DO_CALLS
+        expect(req.response[:request_id]).to be_a Fixnum
+        expect(req.response[:transaction_id]).to be_a Fixnum
+        expect(req.response[:authorization]).to be_nil
+      else
+        expect(req.response[:request_id]).to eq 111111
+        expect(req.response[:transaction_id]).to eq 2222222
+        expect(req.response[:authorization]).to eq 444444
+      end
+    end
+
+    it "should make debit on a prior auth-only" do
+      stub_response "CODEREPONSE=00000&COMMENTAIRE=" if !DO_CALLS
+
+      if DO_CALLS
+        req = PayboxDirect.authorize(
+          ref:        "auth_to_debit",
+          amount:     18.20,
+          currency:   :EUR,
+          cc_number:  CC_NUMBER,
+          cc_expire:  CC_EXPIRE,
+          cc_cvv:     CC_CVV
+        )
+        req_id = req.response[:request_id]
+        trans_id = req.response[:transaction_id]
+      else
+        req_id = 111111
+        trans_id = 2222222
+      end
+
+      req = PayboxDirect.debit_authorization(
+        amount:         18.20,
+        currency:       :EUR,
+        request_id:     req_id,
+        transaction_id: trans_id
+      )
+
+      expect(req.vars).to include({
+        "TYPE"      => "00002",
+        "MONTANT"   => "0000001820",
+        "DEVISE"    => "978",
+        "NUMAPPEL"  => req_id.to_s.rjust(10, "0"),
+        "NUMTRANS"  => trans_id.to_s.rjust(10, "0")
+      })
+    end
+  end
+
+  it "should cancel an operation" do
+    stub_response "CODEREPONSE=00000&COMMENTAIRE=" if !DO_CALLS
+
+    if DO_CALLS
+      req = PayboxDirect.debit(
+        ref:        "debit_to_cancel",
+        amount:     38.14,
+        currency:   :EUR,
+        cc_number:  CC_NUMBER,
+        cc_expire:  CC_EXPIRE,
+        cc_cvv:     CC_CVV
+      )
+      req_id = req.response[:request_id]
+      trans_id = req.response[:transaction_id]
+    else
+      req_id = 111111
+      trans_id = 2222222
+    end
+
+    req = PayboxDirect.cancel(
+      amount:         38.14,
+      currency:       :EUR,
+      ref:            "debit_to_cancel",
+      cc_expire:      CC_EXPIRE,
+      cc_cvv:         CC_CVV,
+      request_id:     req_id,
+      transaction_id: trans_id
+    )
+
+    expect(req.vars).to include({
+      "TYPE"      => "00005",
+      "REFERENCE" => REF_PREFIX + "debit_to_cancel",
+      "MONTANT"   => "0000003814",
+      "DEVISE"    => "978",
+      "DATEVAL"   => CC_EXPIRE.strftime("%m%y"),
+      "CVV"       => CC_CVV,
+      "NUMAPPEL"  => req_id.to_s.rjust(10, "0"),
+      "NUMTRANS"  => trans_id.to_s.rjust(10, "0")
+    })
+  end
+
+  it "should refund a debited payment" do
+    stub_response "CODEREPONSE=00000&COMMENTAIRE="
+
+    req = PayboxDirect.refund(
+      amount:         10.20,
+      currency:       :EUR,
+      request_id:     111111,
+      transaction_id: 2222222
+    )
+
+    expect(req.vars).to include({
+      "TYPE"      => "00014",
+      "MONTANT"   => "0000001020",
+      "DEVISE"    => "978",
+      "NUMAPPEL"  => "0000111111",
+      "NUMTRANS"  => "0002222222"
+    })
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,99 @@
+# Copyright © 2015, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'paybox_direct'
+
+RSpec.describe PayboxDirect::Request do
+  before do
+    PayboxDirect.config.site       = "444444"
+    PayboxDirect.config.rank       = "88"
+    PayboxDirect.config.login      = "my_login"
+    PayboxDirect.config.password   = "my_password"
+    PayboxDirect.config.version    = 104
+    PayboxDirect.config.activity   = 24
+    PayboxDirect.config.bank       = "ems"
+    PayboxDirect.config.is_prod    = false
+  end
+
+  it "should assign variables" do
+    fake_time = DateTime.parse("2015-09-12 13:32:51").to_time.utc
+    expect(Time).to receive(:new).with(no_args).at_least(:once).and_return(fake_time)
+
+    req = PayboxDirect::Request.new("VAR1" => "VAL1", "VAR2" => "VAL2")
+    expect(req.vars).to eq({
+      "VERSION"     => "00104",
+      "SITE"        => "0444444",
+      "RANG"        => "88",
+      "CLE"         => "my_password",
+      "DATEQ"       => "12092015133251",
+      "NUMQUESTION" => "0133251000",
+      "ACTIVITE"    => "024",
+      "ACQUEREUR"   => "ems",
+      "VAR1"        => "VAL1",
+      "VAR2"        => "VAL2"
+    })
+  end
+
+  it "should parse result error codes" do
+    stub_response "CODEREPONSE=00008&COMMENTAIRE=My+error+description"
+
+    req = PayboxDirect::Request.new("VAR1" => "VAL1", "VAR2" => "VAL2")
+    req.execute!
+
+    expect(req).to be_failed
+    expect(req.error_code).to eq 8
+    expect(req.error_comment).to eq "My error description"
+  end
+
+  it "should raise ServerUnavailable in dev" do
+    was_prod = PayboxDirect.config.is_prod
+    PayboxDirect.config.is_prod = false
+    dev_uri = URI(PayboxDirect::DEV_URL)
+
+    req = PayboxDirect::Request.new("VAR1" => "VAL1", "VAR2" => "VAL2")
+    expect(req).to receive(:run_http_post!).with(dev_uri).and_raise(SocketError)
+    expect {
+      req.execute!
+    }.to raise_error(PayboxDirect::ServerUnavailableError)
+
+    PayboxDirect.config.is_prod = was_prod
+  end
+
+  it "should fallback on alt URL in prod" do
+    was_prod = PayboxDirect.config.is_prod
+    PayboxDirect.config.is_prod = true
+    prod_uri = URI(PayboxDirect::PROD_URL)
+    prod_fallback_uri = URI(PayboxDirect::PROD_FALLBACK_URL)
+
+    req = PayboxDirect::Request.new("VAR1" => "VAL1", "VAR2" => "VAL2")
+    expect(req).to receive(:run_http_post!).with(prod_uri).and_raise(SocketError)
+    expect(req).to receive(:run_http_post!).with(prod_fallback_uri) {
+      OpenStruct.new({
+        code: "200",
+        body: "CODEREPONSE=00000&COMMENTAIRE=OK"
+      })
+    }
+    req.execute!
+    expect(req).not_to be_failed
+
+    PayboxDirect.config.is_prod = was_prod
+  end
+
+  it "should raise ServerUnavailable in prod" do
+    was_prod = PayboxDirect.config.is_prod
+    PayboxDirect.config.is_prod = true
+    prod_uri = URI(PayboxDirect::PROD_URL)
+    prod_fallback_uri = URI(PayboxDirect::PROD_FALLBACK_URL)
+
+    req = PayboxDirect::Request.new("VAR1" => "VAL1", "VAR2" => "VAL2")
+    expect(req).to receive(:run_http_post!).with(prod_uri).and_raise(SocketError)
+    expect(req).to receive(:run_http_post!).with(prod_fallback_uri).and_raise(SocketError)
+    expect {
+      req.execute!
+    }.to raise_error(PayboxDirect::ServerUnavailableError)
+
+    PayboxDirect.config.is_prod = was_prod
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,117 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end
+
+require 'date'
+
+DO_CALLS   = ENV.key?("PB_SITE") and ENV.key?("PB_RANK") and ENV.key?("PB_LOGIN") and ENV.key?("PB_PASSWORD")
+SITE       = ENV["PB_SITE"] || "5555555"
+RANK       = ENV["PB_RANK"] || "88"
+LOGIN      = ENV["PB_LOGIN"] || "my_test_login"
+PASSWORD   = ENV["PB_PASSWORD"] || "my_test_password"
+REF_PREFIX = "test_#{Time.new.strftime("%Y%m%d%H%I%S%L")}_"
+CC_NUMBER  = "4012-0010-3844-3335"
+CC_EXPIRE  = Date.new(2016, 10, 1)
+CC_CVV     = "123"
+
+def stub_response(query, status = "200")
+  allow_any_instance_of(PayboxDirect::Request).to receive(:run_http_post!) {
+    OpenStruct.new({
+      code: status,
+      body: query
+    })
+  }
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: paybox_direct
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kévin Lesénéchal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: kevin.lesenechal@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/paybox_direct.rb
+- spec/paybox_direct_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kevin-lesenechal/paybox_direct
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: An API to Paybox Direct and Paybox Direct Plus
+test_files: []