paypal-masspay 1.1.0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Envato
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Paypal::Masspay
+
+Paypal::Masspay is a Ruby library that uses PayPals MassPay API to send Mass Payments.
+
+The MassPay API provides a SOAP and NVP (Name-Value Pair) interface, however this library uses the NVP interface exclusively.
+
+You can read more about PayPals MassPay API at the following link: [PayPal MassPay API Documentationn](https://developer.paypal.com/docs/classic/mass-pay/integration-guide/MassPayUsingAPI/)
+
+A introduction about PayPals NVP interface in general can be found here: [PayPal NVP API Overview](https://developer.paypal.com/docs/classic/api/NVPAPIOverview/)
+
+## Usage
+
+In a nutshell the Paypal::Masspay library lets you send multiple payments at once using the following schema:
+
+``` ruby
+Paypal::Masspay::Configuration.configure do |config|
+  config.environment  = :production
+  config.username     = 'your_paypal_username'
+  config.password     = 'your_paypal_password'
+  config.signature    = 'your_paypal_signature'
+end
+
+masspay = Paypal::Masspay.new(:currency  => 'USD') do |bucket|
+    bucket.add_recipient(Paypal::Masspay::Recipient.new(:recipient_email => 'chunky@example.com', :amount => 10.00, :unique_id => 1234, :note => 'hello'))
+    bucket.add_recipient(Paypal::Masspay::Recipient.new(:recipient_email => 'bacon@example.com', :amount => 2.95, :unique_id => 222))
+end
+
+masspay.deliver
+```
+
+It also supports being used like this:
+``` ruby
+Paypal::Masspay::Configuration.configure do |config|
+  config.environment  = :production
+  config.username     = 'your_paypal_username'
+  config.password     = 'your_paypal_password'
+  config.signature    = 'your_paypal_signature'
+end
+
+recipients = [
+  Paypal::Masspay::Recipient.new(
+    :recipient_email => 'chunky@example.com',
+    :amount          => 10.00,
+    :unique_id       => 1234,
+    :note            => 'hello'),
+  Paypal::Masspay::Recipient.new(
+    :recipient_email => 'bacon@example.com',
+    :amount          => 2.95,
+    :unique_id       => 222)
+ ]
+
+masspay = Paypal::Masspay.new(:currency => 'USD', :recipients => recipients)
+
+masspay.deliver
+```
+
+This sends a post request to the PayPal NVP API endpoint containing the following data:
+
+```
+USER=your_paypal_username&
+PWD=your_paypal_password&
+SIGNATURE=your_paypal_signature&
+VERSION=2.3&
+METHOD=MassPay&
+RECEIVERTYPE=EmailAddress&
+L_EMAIL0=chunky@example.com&
+L_AMT0=10.00&
+L_UNIQUEID0=1234&
+L_NOTE0=hello&
+L_EMAIL1=bacon@example.com&
+L_AMT1=2.95&
+L_UNIQUEID1=222&
+CURRENCYCODE=USD
+```
+
+You are also able to check whether or not the request was successfully sent to paypal, and can check any returned error/warnings using the following code:
+
+``` ruby
+masspay.successful? # ===> true/false
+
+masspay.errors                  # ===> [ <Paypal::Masspay::Error>, <Paypal::Masspay::Error>, ... ]
+masspay.errors[0].methods       # ===> [ :code, :short_message, :long_message, :severity ]
+masspay.errors[0].code          # ===> 10000
+masspay.errors[0].short_message # ===> "insufficient funds"
+```

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require 'cane'
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.no_style = true
+    cane.no_doc = true
+  end
+rescue LoadError
+  warn "cane not available, quality task not provided."
+end
+
+task :default => [ :quality, :spec ]

data/lib/paypal/masspay.rb

@@ -0,0 +1,131 @@
+require 'paypal/masspay/version'
+require 'paypal/masspay/response_parser'
+require 'paypal/masspay/recipient'
+require 'paypal/masspay/length_validator'
+require 'paypal/masspay/configuration'
+
+require 'faraday'
+require 'ostruct'
+
+module Paypal
+  class Masspay
+    SANDBOX_API_URL    = 'https://api-3t.sandbox.paypal.com'
+    PRODUCTION_API_URL = 'https://api-3t.paypal.com'
+    API_PATH           = '/nvp'
+    API_VERSION        = '2.3'
+    IDENTIFIER         = 'EmailAddress'
+    METHOD             = 'MassPay'
+    MAX_PER_REQUEST    = 250
+
+    DEFAULT_CURRENCY   = 'USD'
+    DEFAULT_SUBJECT    = 'Paypal Masspay'
+
+    CURRENCY_MAX_LENGTH = 3
+    SUBJECT_MAX_LENGTH  = 255
+
+    attr_reader :errors
+
+    def initialize(options = {}, &block)
+      build_options(options)
+
+      @success   = true
+      @delivered = false
+      @errors    = []
+
+      yield(self) if block_given?
+    end
+
+    def add_recipient(recipient)
+      @recipients << recipient
+    end
+
+    def deliver
+      validate
+
+      connection = create_connection
+
+      @recipients.each_slice(MAX_PER_REQUEST) do |recipients_slice|
+        response = connection.post(API_PATH, request_data(recipients_slice))
+        check_response(response)
+      end
+
+      @delivered = true
+    end
+
+    def successful?
+      @success
+    end
+
+    def delivered?
+      @delivered
+    end
+
+    private
+
+    def validate
+      Paypal::Masspay::LengthValidator.validate(@currency, CURRENCY_MAX_LENGTH, :currency)
+      Paypal::Masspay::LengthValidator.validate(@subject, SUBJECT_MAX_LENGTH, :subject)
+    end
+
+    def create_connection
+      Faraday.new(:url => api_url) do |con|
+        con.use(Faraday::Request::UrlEncoded)
+        con.use(Faraday::Adapter::NetHttp)
+      end
+    end
+
+    def api_url
+      if Paypal::Masspay::Configuration.environment == :production
+        PRODUCTION_API_URL
+      else
+        SANDBOX_API_URL
+      end
+    end
+
+    def check_response(response)
+      response = Paypal::Masspay::ResponseParser.new(response.body)
+      if response.successful?
+        @success = true && @success
+      else
+        @success = false
+        @errors.concat(response.errors)
+      end
+    end
+
+    def request_data(recipients)
+      (default_options.merge(credentials).merge(build_payments(recipients))).delete_if { |k, v| v.nil? }
+    end
+
+    def build_options(options)
+      @recipients  = options[:recipients] || []
+      @currency    = options[:currency]   || DEFAULT_CURRENCY
+      @subject     = options[:subject]    || DEFAULT_SUBJECT
+    end
+
+    def build_payments(recipients)
+      Hash.new({}).tap do |output|
+        recipients.each_with_index do |payment, index|
+          output.merge!(payment.get_params(index))
+        end
+      end
+    end
+
+    def credentials
+      {
+        'USER'      => Paypal::Masspay::Configuration.username,
+        'PWD'       => Paypal::Masspay::Configuration.password,
+        'SIGNATURE' => Paypal::Masspay::Configuration.signature
+      }
+    end
+
+    def default_options
+      {
+        'VERSION'      => API_VERSION,
+        'METHOD'       => METHOD,
+        'RECEIVERTYPE' => IDENTIFIER,
+        'CURRENCYCODE' => @currency,
+        'EMAILSUBJECT' => @subject
+      }
+    end
+  end
+end

data/lib/paypal/masspay/configuration.rb

@@ -0,0 +1,13 @@
+module Paypal
+  class Masspay::Configuration
+    class << self
+      attr_accessor :environment, :username, :password, :signature
+
+      def configure
+        @configuration ||= Paypal::Masspay::Configuration.tap do |config|
+          yield config
+        end
+      end
+    end
+  end
+end

data/lib/paypal/masspay/error.rb

@@ -0,0 +1,12 @@
+module Paypal
+  class Masspay::Error
+    attr_reader :code, :short_message, :long_message, :severity
+
+    def initialize(params = {})
+      @code          = params[:code]
+      @short_message = params[:short_message]
+      @long_message  = params[:long_message]
+      @severity      = params[:severity]
+    end
+  end
+end

data/lib/paypal/masspay/length_validator.rb

@@ -0,0 +1,11 @@
+module Paypal
+  class Masspay::LengthValidator
+    class FieldLengthTooLarge < StandardError; end
+
+    def self.validate(string, length, field_name)
+      string.tap do |output|
+        raise FieldLengthTooLarge.new("#{output} is longer than the paypal max char limit of #{length} for field #{field_name}") if !output.nil? && output.length > length
+      end
+    end
+  end
+end

data/lib/paypal/masspay/recipient.rb

@@ -0,0 +1,23 @@
+module Paypal
+  class Masspay::Recipient
+    RECIPIENT_EMAIL_MAX_LENGTH     = 127
+    RECIPIENT_NOTE_MAX_LENGTH      = 4000
+    RECIPIENT_UNIQUE_ID_MAX_LENGTH = 30
+
+    def initialize(args = {})
+      @recipient_email = Paypal::Masspay::LengthValidator.validate(args[:recipient_email], RECIPIENT_EMAIL_MAX_LENGTH, :recipient_email)
+      @note            = Paypal::Masspay::LengthValidator.validate(args[:note], RECIPIENT_NOTE_MAX_LENGTH, :note)
+      @unique_id       = Paypal::Masspay::LengthValidator.validate(args[:unique_id], RECIPIENT_UNIQUE_ID_MAX_LENGTH, :unique_id)
+      @amount          = args[:amount]
+    end
+
+    def get_params(index)
+      {
+        "L_EMAIL#{index}"    => @recipient_email,
+        "L_AMT#{index}"      => @amount,
+        "L_NOTE#{index}"     => @note,
+        "L_UNIQUEID#{index}" => @unique_id
+      }
+    end
+  end
+end

data/lib/paypal/masspay/response_parser.rb

@@ -0,0 +1,62 @@
+require 'cgi'
+require 'paypal/masspay/error'
+
+module Paypal
+  class Masspay::ResponseParser
+    SUCCESS_ACK           = 'Success'
+    SUCCESS_WITH_WARN_ACK = 'SuccessWithWarning'
+    SUCCESSFUL_ACKS       = [ SUCCESS_ACK, SUCCESS_WITH_WARN_ACK ]
+
+    def initialize(response_body)
+      @response_body = response_body
+      @errors = []
+    end
+
+    def successful?
+      SUCCESSFUL_ACKS.include?(ack)
+    end
+
+    def errors
+      @errors.tap do |errors|
+        parsed_response.select { |k, v| k.match(/^L_ERRORCODE\d+$/) }.keys.count.times do |i|
+          errors << Paypal::Masspay::Error.new(
+            :code          => error_code_for(i),
+            :short_message => short_message_for(i),
+            :long_message  => long_message_for(i),
+            :severity      => severity_for(i))
+        end
+      end
+    end
+
+    private
+
+    def parsed_response
+      if @parsed_response.nil?
+        @parsed_response = CGI::parse(@response_body)
+        @parsed_response.each { |key, value| @parsed_response[key] = value.first }
+      end
+
+      @parsed_response
+    end
+
+    def ack
+      parsed_response["ACK"]
+    end
+
+    def error_code_for(index)
+      parsed_response["L_ERRORCODE#{index}"].to_i
+    end
+
+    def short_message_for(index)
+      parsed_response["L_SHORTMESSAGE#{index}"]
+    end
+
+    def long_message_for(index)
+      parsed_response["L_LONGMESSAGE#{index}"]
+    end
+
+    def severity_for(index)
+      parsed_response["L_SEVERITYCODE#{index}"]
+    end
+  end
+end

data/lib/paypal/masspay/version.rb

@@ -0,0 +1,5 @@
+module Paypal
+  class Masspay
+    VERSION = '1.1.0'
+  end
+end

data/paypal-masspay.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'paypal/masspay/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'paypal-masspay'
+  gem.version       = Paypal::Masspay::VERSION
+  gem.authors       = ['Martin Jagusch', 'Shervin Aflatooni']
+  gem.email         = ['shervinaflatooni@gmail.com']
+  gem.description   = 'Performing multiple payments to PayPal using the MassPay API'
+  gem.summary       = "paypal-masspay-#{Paypal::Masspay::VERSION}"
+  gem.homepage      = 'https://github.com/envato/paypal-masspay'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'faraday', '~> 0.9', '>= 0.9.0'
+
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec', '~> 3.0.0.beta1'
+  gem.add_development_dependency 'cane', '~> 2.6'
+  gem.add_development_dependency 'webmock', '~> 1.17'
+end

data/spec/lib/integration/masspay_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe 'performing a masspay' do
+  let(:success_body)  { 'ACK=Success' }
+  let(:fail_body)     { 'ACK=Failure&L_ERRORCODE0=10000&L_SHORTMESSAGE0=short_error_message&L_LONGMESSAGE0=long_error_message&L_SEVERITYCODE0=Error&L_ERRORCODE1=20000&L_SHORTMESSAGE1=short_error_message2&L_LONGMESSAGE1=long_error_message2&L_SEVERITYCODE1=Error' }
+  let(:response_body) { success_body }
+
+  let(:recipient_one) { Paypal::Masspay::Recipient.new(:recipient_email => 'chunky@example.com', :amount => 10.00) }
+  let(:recipient_two) { Paypal::Masspay::Recipient.new(:recipient_email => 'bacon@example.com', :amount => 2.95) }
+
+  before do
+    stub_request(:post, "https://api-3t.sandbox.paypal.com/nvp").with(
+      :body => {
+        "USER"         => "your_paypal_username",
+        "PWD"          => "your_paypal_password",
+        "SIGNATURE"    => "your_paypal_signature",
+        "CURRENCYCODE" => "USD",
+        "EMAILSUBJECT" => "Paypal Masspay",
+        "L_AMT0"       => "10.0",
+        "L_AMT1"       => "2.95",
+        "L_EMAIL0"     => "chunky@example.com",
+        "L_EMAIL1"     => "bacon@example.com",
+        "METHOD"       => "MassPay",
+        "RECEIVERTYPE" => "EmailAddress",
+        "VERSION"      => "2.3"
+    }).to_return(:body => response_body)
+
+    Paypal::Masspay::Configuration.configure do |config|
+      config.environment  = :sandbox
+      config.username     = 'your_paypal_username'
+      config.password     = 'your_paypal_password'
+      config.signature    = 'your_paypal_signature'
+    end
+  end
+
+  context 'adding recipients one at a time' do
+    before do
+      @masspay = Paypal::Masspay.new(:currency => 'USD', :subject => 'Paypal Masspay') do |bucket|
+        bucket.add_recipient(recipient_one)
+        bucket.add_recipient(recipient_two)
+      end
+    end
+
+    context 'when the response was successful' do
+      let(:response_body) { success_body }
+
+      it 'sends the correct request to the paypal api and is successful' do
+        expect(@masspay).to_not be_delivered
+        @masspay.deliver
+        expect(@masspay).to be_successful
+        expect(@masspay).to be_delivered
+      end
+    end
+
+    context 'when the response was not successful' do
+      let(:response_body) { fail_body }
+
+      it 'sends the correct request to the paypal api and is successful' do
+        @masspay.deliver
+        expect(@masspay).to_not be_successful
+      end
+
+      it 'has 2 errors' do
+        @masspay.deliver
+        expect(@masspay.errors.count).to eq(2)
+      end
+
+      it 'has the correct error codes' do
+        @masspay.deliver
+        expect(@masspay.errors[0].code).to eq(10000)
+        expect(@masspay.errors[1].code).to eq(20000)
+      end
+    end
+  end
+
+  context 'adding recipients in a hash' do
+    let(:recipients) { [recipient_one, recipient_two] }
+
+    before do
+      @masspay = Paypal::Masspay.new(:currency => 'USD', :subject => 'Paypal Masspay', :recipients => recipients)
+    end
+
+    context 'when the response was successful' do
+      let(:response_body) { success_body }
+
+      it 'sends the correct request to the paypal api and is successful' do
+        @masspay.deliver
+        expect(@masspay).to be_successful
+      end
+    end
+  end
+end

data/spec/lib/paypal/masspay/error_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Paypal::Masspay::Error do
+  let(:code)          { double }
+  let(:short_message) { double }
+  let(:long_message)  { double }
+  let(:severity)      { double }
+  let(:arguments)     { { :code => code, :short_message => short_message, :long_message => long_message, :severity => severity } }
+  subject(:error)     { Paypal::Masspay::Error.new(arguments) }
+
+  describe '#code' do
+    it 'returns the error code' do
+      expect(error.code).to eq(code)
+    end
+  end
+
+  describe '#short_message' do
+    it 'returns the error short_message' do
+      expect(error.short_message).to eq(short_message)
+    end
+  end
+
+  describe '#long_message' do
+    it 'returns the error long_message' do
+      expect(error.long_message).to eq(long_message)
+    end
+  end
+
+  describe '#severity' do
+    it 'returns the error severity' do
+      expect(error.severity).to eq(severity)
+    end
+  end
+end

data/spec/lib/paypal/masspay/length_validator_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Paypal::Masspay::LengthValidator do
+  describe '.validate' do
+    context 'the string is valid' do
+      it 'returns the string' do
+        expect(Paypal::Masspay::LengthValidator.validate("hello", 5, :test)).to eq("hello")
+      end
+    end
+
+    context 'the string is not valid' do
+      it 'raises a field too large exception' do
+        expect { Paypal::Masspay::LengthValidator.validate("hello", 4, :test) }.to raise_error(Paypal::Masspay::LengthValidator::FieldLengthTooLarge)
+      end
+    end
+  end
+end

data/spec/lib/paypal/masspay/recipient_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Paypal::Masspay::Recipient do
+  let(:recipient_email) { double }
+  let(:amount)          { double }
+  let(:note)            { double }
+  let(:unique_id)       { double }
+  let(:arguments)       { { :recipient_email => recipient_email, :amount => amount, :note => note, :unique_id => unique_id } }
+  subject(:recipient)   { Paypal::Masspay::Recipient.new(arguments) }
+
+  before do
+    allow(Paypal::Masspay::LengthValidator).to receive(:validate).with(recipient_email, 127, :recipient_email).and_return(recipient_email)
+    allow(Paypal::Masspay::LengthValidator).to receive(:validate).with(note, 4000, :note).and_return(note)
+    allow(Paypal::Masspay::LengthValidator).to receive(:validate).with(unique_id, 30, :unique_id).and_return(unique_id)
+  end
+
+  describe '#get_params' do
+    it 'returns the arguments in the correct format' do
+      expect(recipient.get_params(5)).to eq({
+        "L_EMAIL5"    => recipient_email,
+        "L_AMT5"      => amount,
+        "L_NOTE5"     => note,
+        "L_UNIQUEID5" => unique_id
+      })
+    end
+  end
+end

data/spec/lib/paypal/masspay/response_parser_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Paypal::Masspay::ResponseParser do
+  let(:success_body)        { 'ACK=Success' }
+  let(:fail_body)           { 'ACK=Failure&L_ERRORCODE0=10000&L_SHORTMESSAGE0=short_error_message&L_LONGMESSAGE0=long_error_message&L_SEVERITYCODE0=Error&L_ERRORCODE1=20000&L_SHORTMESSAGE1=short_error_message2&L_LONGMESSAGE1=long_error_message2&L_SEVERITYCODE1=Error' }
+  let(:response_body)       { success_body }
+  subject(:response_parser) { Paypal::Masspay::ResponseParser.new(response_body) }
+
+  describe '#successful?' do
+    context 'the response was successful' do
+      let(:response_body) { success_body }
+
+      it 'returns true' do
+        expect(response_parser).to be_successful
+      end
+    end
+
+    context 'the response was not successful' do
+      let(:response_body) { fail_body }
+
+      it 'returns false' do
+        expect(response_parser).to_not be_successful
+      end
+    end
+  end
+
+  describe '#errors' do
+    context 'the response was successful' do
+      let(:response_body) { success_body }
+
+      it 'has no errors' do
+        expect(response_parser.errors.count).to eq(0)
+      end
+    end
+
+    context 'the response was not successful' do
+      let(:response_body) { fail_body }
+
+      it 'has errors' do
+        expect(response_parser.errors.count).to eq(2)
+      end
+    end
+  end
+end

data/spec/lib/paypal/masspay_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Paypal::Masspay do
+  let(:recipient_one) { double }
+  let(:recipient_two) { double }
+  let(:response)    { double(:successful? => successful, :errors => errors) }
+  let(:errors)      { [] }
+
+  let(:successful)    { true }
+  let(:success_body)  { 'ACK=Success' }
+  let(:fail_body)     { 'ACK=Failure&L_ERRORCODE0=10000&L_SHORTMESSAGE0=short_error_message&L_LONGMESSAGE0=long_error_message&L_SEVERITYCODE0=Error&L_ERRORCODE1=20000&L_SHORTMESSAGE1=short_error_message2&L_LONGMESSAGE1=long_error_message2&L_SEVERITYCODE1=Error' }
+  let(:response_body) { success_body }
+
+  before do
+    allow(Paypal::Masspay::Configuration).to receive(:environment).and_return(:sandbox)
+    allow(Paypal::Masspay::Configuration).to receive(:username).and_return("user1")
+    allow(Paypal::Masspay::Configuration).to receive(:password).and_return("password1")
+    allow(Paypal::Masspay::Configuration).to receive(:signature).and_return("sig1")
+
+    allow(recipient_one).to receive(:get_params).with(0).and_return({"L_EMAIL0" => 'chunky@example.com', "L_AMT0" => 10.0})
+    allow(recipient_two).to receive(:get_params).with(1).and_return({"L_EMAIL1" => 'bacon@example.com', "L_AMT1" => 2.95})
+    allow(Paypal::Masspay::ResponseParser).to receive(:new).with(response_body).and_return(response)
+
+    allow(Paypal::Masspay::LengthValidator).to receive(:validate).with('USD', 3, :currency).and_return('USD')
+    allow(Paypal::Masspay::LengthValidator).to receive(:validate).with('Paypal Masspay', 255, :subject).and_return('Paypal Masspay')
+
+    stub_request(:post, "https://api-3t.sandbox.paypal.com/nvp").with(
+      :body => {
+        "USER"         => "user1",
+        "PWD"          => "password1",
+        "SIGNATURE"    => "sig1",
+        "CURRENCYCODE" => "USD",
+        "EMAILSUBJECT" => "Paypal Masspay",
+        "L_AMT0"       => "10.0",
+        "L_AMT1"       => "2.95",
+        "L_EMAIL0"     => "chunky@example.com",
+        "L_EMAIL1"     => "bacon@example.com",
+        "METHOD"       => "MassPay",
+        "RECEIVERTYPE" => "EmailAddress",
+        "VERSION"      => "2.3"
+    }).to_return(:body => response_body)
+  end
+
+  context 'adding recipients one at a time' do
+    before do
+
+      @masspay = Paypal::Masspay.new(:currency => 'USD', :subject => 'Paypal Masspay') do |bucket|
+        bucket.add_recipient(recipient_one)
+        bucket.add_recipient(recipient_two)
+      end
+    end
+
+    context 'when the response was successful' do
+      let(:response_body) { success_body }
+      let(:successful)    { true }
+      let(:errors)        { [] }
+
+      it 'sends the correct request to the paypal api and is successful' do
+        expect(@masspay).to_not be_delivered
+        @masspay.deliver
+        expect(@masspay).to be_successful
+        expect(@masspay).to be_delivered
+      end
+    end
+
+    context 'when the response was not successful' do
+      let(:response_body) { fail_body }
+      let(:successful)    { false }
+      let(:errors)        { [ double, double ] }
+
+      it 'sends the correct request to the paypal api and is successful' do
+        @masspay.deliver
+        expect(@masspay).to_not be_successful
+      end
+
+      it 'has 2 errors' do
+        @masspay.deliver
+        expect(@masspay.errors.count).to eq(2)
+      end
+    end
+  end
+
+  context 'adding recipients in a hash' do
+    let(:recipients) { [recipient_one, recipient_two] }
+
+    before do
+      @masspay = Paypal::Masspay.new(:currency => 'USD', :subject => 'Paypal Masspay', :recipients => recipients)
+    end
+
+    context 'when the response was successful' do
+      let(:response_body) { success_body }
+      let(:successful)    { true }
+      let(:errors)        { [] }
+
+      it 'sends the correct request to the paypal api and is successful' do
+        @masspay.deliver
+        expect(@masspay).to be_successful
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'paypal/masspay'
+require 'rspec'
+require 'webmock/rspec'

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: paypal-masspay
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Martin Jagusch
+- Shervin Aflatooni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+description: Performing multiple payments to PayPal using the MassPay API
+email:
+- shervinaflatooni@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/paypal/masspay.rb
+- lib/paypal/masspay/configuration.rb
+- lib/paypal/masspay/error.rb
+- lib/paypal/masspay/length_validator.rb
+- lib/paypal/masspay/recipient.rb
+- lib/paypal/masspay/response_parser.rb
+- lib/paypal/masspay/version.rb
+- paypal-masspay.gemspec
+- spec/lib/integration/masspay_spec.rb
+- spec/lib/paypal/masspay/error_spec.rb
+- spec/lib/paypal/masspay/length_validator_spec.rb
+- spec/lib/paypal/masspay/recipient_spec.rb
+- spec/lib/paypal/masspay/response_parser_spec.rb
+- spec/lib/paypal/masspay_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/envato/paypal-masspay
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: paypal-masspay-1.1.0
+test_files:
+- spec/lib/integration/masspay_spec.rb
+- spec/lib/paypal/masspay/error_spec.rb
+- spec/lib/paypal/masspay/length_validator_spec.rb
+- spec/lib/paypal/masspay/recipient_spec.rb
+- spec/lib/paypal/masspay/response_parser_spec.rb
+- spec/lib/paypal/masspay_spec.rb
+- spec/spec_helper.rb