paypal-sdk-rest-pmrb 1.8.0

data/spec/payouts_examples_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe "Payouts", :integration => true do
+
+  PayoutVenmoAttributes = {
+      :sender_batch_header => {
+          :sender_batch_id => SecureRandom.hex(8)
+      },
+      :items => [
+          {
+              :recipient_type => 'PHONE',
+              :amount => {
+                  :value => '1.0',
+                  :currency => 'USD'
+              },
+              :note => 'Thanks for your patronage!',
+              :sender_item_id => '2014031400023',
+              :receiver => '5551232368',
+              :recipient_wallet => 'VENMO'
+          }
+      ]
+  }
+
+  PayoutAttributes = {
+      :sender_batch_header => {
+          :sender_batch_id => SecureRandom.hex(8),
+          :email_subject => 'You have a Payout!'
+      },
+      :items => [
+          {
+              :recipient_type => 'EMAIL',
+              :amount => {
+                  :value => '1.0',
+                  :currency => 'USD'
+              },
+              :note => 'Thanks for your patronage!',
+              :sender_item_id => '2014031400023',
+              :receiver => 'shirt-supplier-one@mail.com'
+          }
+      ]
+  }
+
+  it "create venmo payout" do
+    $payout = PayPal::SDK::REST::Payout.new(PayoutVenmoAttributes)
+    $payout_batch = $payout.create
+    expect($payout_batch).to be_truthy
+  end
+
+  it "create payout sync" do
+    $payout = PayPal::SDK::REST::Payout.new(PayoutAttributes)
+    $payout_batch = $payout.create(true)
+    expect($payout_batch).to be_truthy
+  end
+
+  it "get payout batch status" do
+    $result = PayPal::SDK::REST::Payout.get($payout_batch.batch_header.payout_batch_id)
+    expect($result).to be_a PayPal::SDK::REST::PayoutBatch
+    expect($payout_batch.batch_header.payout_batch_id).to eql $result.batch_header.payout_batch_id
+  end
+
+  it "get payout item status" do
+    $payout_item_details= PayoutItem.get($payout_batch.items[0].payout_item_id)
+    expect($payout_item_details).to be_a PayPal::SDK::REST::PayoutItemDetails
+    expect($payout_item_details.payout_item_id).to eql $payout_batch.items[0].payout_item_id
+  end
+
+  it "cancel unclaimed payouts" do
+    $payout_item_details= PayoutItem.cancel($payout_batch.items[0].payout_item_id)
+    expect($payout_item_details).to be_a PayPal::SDK::REST::PayoutItemDetails
+    expect($payout_item_details.payout_item_id).to eql $payout_batch.items[0].payout_item_id
+    expect($payout_item_details.transaction_status).to eql 'RETURNED'
+  end
+
+end

data/spec/rest/data_types_spec.rb

@@ -0,0 +1,62 @@
+module PayPal::SDK::REST::DataTypes
+  describe Base do
+    let(:error_object) {
+      {
+        "name" => "INVALID_EXPERIENCE_PROFILE_ID",
+        "message" => "The requested experience profile ID was not found",
+        "information_link" => "https://developer.paypal.com/docs/api/#INVALID_EXPERIENCE_PROFILE_ID",
+        "debug_id" => "1562931a79fd2"
+      }
+    }
+
+    context '#raise_error!' do
+      context 'when there is error' do
+        subject { described_class.new(error: error_object) }
+
+        it 'raises error on request with all API information' do
+          expect { subject.raise_error! }
+            .to raise_error { |err|
+              expect(err).to be_a(PayPal::SDK::Core::Exceptions::UnsuccessfulApiCall)
+              expect(err.message).to eq("The requested experience profile ID was not found")
+              expect(err.api_error).to eq(error_object)
+            }
+        end
+      end
+
+      context 'when there is no error' do
+        subject { described_class.new(error: nil) }
+
+        it { expect { subject.raise_error! }.not_to raise_error }
+      end
+    end
+
+    context '.raise_on_api_error' do
+      let(:klass) {
+        Class.new(described_class) do
+          def some_call
+          end
+
+          raise_on_api_error :some_call
+        end
+      }
+
+      subject { klass.new }
+
+      context 'when call is successful' do
+        before {
+          expect(subject).to receive(:some_call).and_return(true)
+        }
+        it { expect { subject.some_call! }.not_to raise_error }
+      end
+
+      context 'when call is unsuccessful' do
+        before {
+          expect(subject).to receive(:some_call).and_return(false)
+          expect(subject).to receive(:error).twice.and_return(error_object)
+        }
+
+        it { expect { subject.some_call! }.to raise_error(PayPal::SDK::Core::Exceptions::UnsuccessfulApiCall) }
+      end
+    end
+  end
+end

data/spec/rest/error_hash_spec.rb

@@ -0,0 +1,83 @@
+module PayPal::SDK::REST
+  describe ErrorHash do
+    it 'converts Hashes to ErrorHashes' do
+      hash = ErrorHash.convert({
+        nested_hash: { bing: 'bong' },
+        empty_array: [],
+        array_with_hashes: [
+          { foo: 'boo' },
+          { biz: 'boz' }
+        ],
+        array_without_hashes: [1, 2, 3],
+        nilly: nil,
+        stringy: 'cheese'
+      })
+
+      expect(hash).to be_a(ErrorHash)
+      expect(hash.nested_hash).to be_a(ErrorHash)
+      expect(hash.empty_array).to eq([])
+      expect(hash.array_with_hashes[0]).to be_a(ErrorHash)
+      expect(hash.array_with_hashes[1]).to be_a(ErrorHash)
+      expect(hash.array_without_hashes).to eq([1, 2, 3])
+      expect(hash.nilly).to be_nil
+      expect(hash.stringy).to eq('cheese')
+    end
+
+    it 'can access string keys as properties, strings, or symbols' do
+      hash = ErrorHash.convert({ 'foo' => 5 })
+      hash['boo'] = 'grue'
+
+      expect(hash.foo).to eq(5)
+      expect(hash['foo']).to eq(5)
+      expect(hash[:foo]).to eq(5)
+      expect(hash.boo).to eq('grue')
+      expect(hash['boo']).to eq('grue')
+      expect(hash[:boo]).to eq('grue')
+    end
+
+    it 'can access symbol keys as properties, strings, or symbols' do
+      hash = ErrorHash.convert({ :foo => 5 })
+      hash[:boo] = 'grue'
+
+      expect(hash.foo).to eq(5)
+      expect(hash['foo']).to eq(5)
+      expect(hash[:foo]).to eq(5)
+      expect(hash.boo).to eq('grue')
+      expect(hash['boo']).to eq('grue')
+      expect(hash[:boo]).to eq('grue')
+    end
+
+    it 'converts Hashes to ErrorHashes on assignment' do
+      hash = ErrorHash.new
+      hash['foo'] = { bing: 'bong' }
+
+      expect(hash['foo']).to be_a(ErrorHash)
+      expect(hash['foo'].bing).to eq('bong')
+    end
+
+    it 'converts Hashes inside of Arrays to ErrorHashes on assignment' do
+      hash = ErrorHash.new
+      hash['foo'] = [{ bing: 'bong' }]
+
+      expect(hash['foo'][0]).to be_a(ErrorHash)
+      expect(hash['foo'][0].bing).to eq('bong')
+    end
+
+    it "doesn't convert Hashes inside of Arrays if the first element of the array isn't a Hash" do
+      hash = ErrorHash.new
+      hash['foo'] = [100, { bing: 'bong' }]
+
+      expect(hash['foo'][1]).to be_a(Hash)
+      expect(hash['foo'][1]).not_to be_a(ErrorHash)
+    end
+
+    it 'gets and sets numbers and strings' do
+      hash = ErrorHash.new
+      hash['foo'] = 123
+      hash['boo'] = 'baa'
+
+      expect(hash['foo']).to eq(123)
+      expect(hash['boo']).to eq('baa')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'bundler/setup'
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  require 'coveralls'
+  Coveralls.wear!
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+Bundler.require :default, :test
+PayPal::SDK::Core::Config.load(File.expand_path('../config/paypal.yml', __FILE__), 'test')
+
+require 'paypal-sdk-rest'
+
+include PayPal::SDK::REST
+include PayPal::SDK::Core::Logging
+
+require 'logger'
+PayPal::SDK.load('spec/config/paypal.yml', 'test')
+PayPal::SDK.logger = Logger.new(STDERR)
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f }
+
+# Set logger for http
+http_log = File.open(File.expand_path('../log/http.log', __FILE__), "w")
+Payment.api.http.set_debug_output(http_log)
+
+RSpec.configure do |config|
+  config.filter_run_excluding :integration => true
+  config.filter_run_excluding :disabled => true
+  config.include SampleData
+  # config.include PayPal::SDK::REST::DataTypes
+end
+
+WebMock.allow_net_connect!

data/spec/subscription_examples_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+describe "Subscription" do
+
+  PlanAttributes = {
+    "name" => "T-Shirt of the Month Club Plan",
+    "description" => "Template creation.",
+    "type" => "fixed",
+    "payment_definitions" => [
+        {
+            "name" => "Regular Payments",
+            "type" => "REGULAR",
+            "frequency" => "MONTH",
+            "frequency_interval" => "2",
+            "amount" => {
+                "value" => "100",
+                "currency" => "USD"
+            },
+            "cycles" => "12",
+            "charge_models" => [
+                {
+                    "type" => "SHIPPING",
+                    "amount" => {
+                        "value" => "10",
+                        "currency" => "USD"
+                    }
+                },
+                {
+                    "type" => "TAX",
+                    "amount" => {
+                        "value" => "12",
+                        "currency" => "USD"
+                    }
+                }
+            ]
+        }
+    ],
+    "merchant_preferences" => {
+        "setup_fee" => {
+            "value" => "1",
+            "currency" => "USD"
+        },
+        "return_url" => "http://www.return.com",
+        "cancel_url" => "http://www.cancel.com",
+        "auto_bill_amount" => "YES",
+        "initial_fail_amount_action" => "CONTINUE",
+        "max_fail_attempts" => "0"
+    }
+  }
+
+  AgreementAttributes = {
+    "name" => "T-Shirt of the Month Club Agreement",
+    "description" => "Agreement for T-Shirt of the Month Club Plan",
+    "start_date" => "2015-02-19T00:37:04Z",
+    "payer" => {
+        "payment_method" => "paypal"
+    },
+    "shipping_address" => {
+        "line1" => "111 First Street",
+        "city" => "Saratoga",
+        "state" => "CA",
+        "postal_code" => "95070",
+        "country_code" => "US"
+    }
+}
+
+  describe "BillingPlan", :integration => true do
+    it "Create" do
+      # create access token and then create a plan
+      $api = API.new
+      plan = Plan.new(PlanAttributes.merge( :token => $api.token ))
+      expect(Plan.api).not_to eql plan.api
+      plan.create
+
+      # make sure the transaction was successful
+      $plan_id = plan.id
+      expect(plan.error).to be_nil
+      expect(plan.id).not_to be_nil
+    end
+
+    it "Update" do
+      # create a new plan to update
+      plan = Plan.new(PlanAttributes)
+      expect(plan.create).to be_truthy
+
+      # set up a patch request
+      patch = Patch.new
+      patch.op = "replace"
+      patch.path = "/";
+      patch.value = { :state => "ACTIVE" }
+
+      # the patch request should be successful
+      expect(plan.update( patch )).to be_truthy
+    end
+
+    it "List" do
+      # list all billing plans
+      plan_list = Plan.all
+      expect(plan_list.error).to be_nil
+      expect(plan_list.plans.count).to be > 1
+    end
+
+    it "Delete" do
+      # create a plan to delete
+      plan = Plan.new(PlanAttributes.merge( :token => $api.token ))
+      plan.create
+      plan_id = plan.id
+
+      # construct a patch object that will be used for deletion
+      patch = Patch.new
+      patch.op = "replace"
+      patch.path = "/"
+      patch.value = { "state" => "DELETED" }
+
+      # send delete request
+      plan.update(patch)
+
+      # make sure the plan has been deleted
+      plan = Plan.find(plan_id)
+      expect(plan.id).not_to eq plan_id
+    end
+  end
+
+  describe "BillingAgreement", :integration => true do
+
+    it "Create" do
+      # first, create an active plan to be added to agreement
+      api = API.new
+      plan = Plan.new(PlanAttributes)
+      expect(plan.create).to be_truthy
+
+      # first, create an agreement
+      $agreement = Agreement.new(AgreementAttributes)
+      $agreement.plan = Plan.new( :id => "P-1K47639161110773GYDKTWIA" )
+      $agreement.shipping_address = nil
+
+      # verify newly created agreement
+      expect($agreement.create).to be_truthy
+      expect($agreement.id).to be_nil
+      expect($agreement.token).not_to be_nil
+      expect($agreement.name).to eq("T-Shirt of the Month Club Agreement")
+    end
+
+    #####################################
+    # The following tests are disabled due to them requiring an active billing agreement or buyer's approval.
+    # Most of them require an agreement ID, which is returned after executing agreement. 
+    # And agreement execution requires buyer's approval.
+    #####################################
+
+    xit "Execute" do
+      # Use this call to execute an agreement after the buyer approves it.
+      expect($agreement.execute).to be_truthy
+    end
+
+    xit "Get" do
+      # this call needs an agreement ID of the agreement to be retrieved
+      agreement = Agreement.find($agreement.id)
+      expect(agreement.id).to eq($agreement.id)
+      expect(agreement.description).to eq("Agreement for T-Shirt of the Month Club Plan")
+      expect(agreement.start_date).to eq("2015-02-19T00:37:04Z")
+      expect(agreement.plan).not_to be_nil
+    end
+
+    xit "Update" do
+      # get the agreement to update
+      api = API.new
+      plan = Plan.new(PlanAttributes)
+      expect(plan.create).to be_truthy
+
+      # first, create an agreement
+      agreement = Agreement.new(AgreementAttributes)
+      agreement.plan = Plan.new( :id => "P-1K47639161110773GYDKTWIA" )
+      expect(agreement.create).to be_truthy
+
+
+      # create an update for the agreement
+      random_string = (0...8).map { (65 + rand(26)).chr }.join
+      patch = Patch.new
+      patch.op = "replace"
+      patch.path = "/" 
+      patch.value = { "description" => random_string }
+
+      # send update request
+      response = agreement.update(patch)
+
+      # verify the agreement update was successful
+      expect(response).to be_truthy
+      updated_agreement = Agreement.get($agreement.id)
+      expect(updated_agreement.id).to eq($agreement.id)
+      expect(random_string).to eq(updated_agreement.description)
+    end
+
+    xit "Suspend" do
+      # set the id of an active agreement here
+      agreement_id = ""
+      agreement = Agreement.find(agreement_id)
+
+      state_descriptor = AgreementStateDescriptor.new( :note => "Suspending the agreement" )
+      expect( agreement.suspend(state_descriptor) ).to be_truthy
+    end
+
+    xit "Reactivate" do
+      # set the id of a suspended agreement here
+      agreement_id = ""
+      agreement = Agreement.find(agreement_id)
+
+      state_descriptor = AgreementStateDescriptor.new( :note => "Re-activating the agreement" )
+      expect( agreement.re_activate(state_descriptor) ).to be_truthy
+    end
+
+    xit "Search" do
+      transactions = Agreement.transactions($agreement.id, "2015-01-01", "2015-01-10")
+      expect(transactions).not_to be_nil
+      expect(transactions.agreement_transaction_list).not_to be_empty
+    end
+
+    xit "Cancel" do
+      # set the id of an agreement here
+      agreement_id = ""
+      agreement = Agreement.find(agreement_id)
+
+      state_descriptor = AgreementStateDescriptor.new( :note => "Cancelling the agreement" )
+      expect( agreement.cancel(state_descriptor) ).to be_truthy
+    end
+
+  end
+end