paypal-sdk-rest 1.7.3 → 2.0.0.rc2

data/spec/payouts_examples_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe "Payouts", :integration => true do
-
-  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 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

@@ -1,62 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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/subscription_examples_spec.rb

@@ -1,227 +0,0 @@
-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

data/spec/support/sample_data.rb

@@ -1,5 +0,0 @@
-module SampleData
-  def samples
-    @@samples ||= YAML.load(File.read(File.expand_path("../../config/sample_data.yml", __FILE__)))
-  end
-end

data/spec/web_profile_examples_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe "WebProfiles" do
-
-  WebProfileAttributes = {
-    "name" => "YeowZa! T-Shirt Shop",
-    "presentation" => {
-        "brand_name" => "YeowZa! Paypal",
-        "logo_image" => "http://www.yeowza.com",
-        "locale_code" => "US"
-    },
-    "input_fields" => {
-        "allow_note" => true,
-        "no_shipping" => 0,
-        "address_override" => 1
-    },
-    "flow_config" => {
-        "landing_page_type" => "billing",
-        "bank_txn_pending_url" => "http://www.yeowza.com"
-    }
-  }
-
-  describe "Examples" do
-    describe "WebProfile", :integration => true do
-      it "Create" do
-
-        api = API.new
-        $webprofile = WebProfile.new(WebProfileAttributes.merge( :token => api.token ))
-
-        # generate a random number and append it to name
-        suffix = Random.rand(1000000000).to_s
-        $randname = $webprofile.name + suffix
-        $webprofile.name = $randname
-
-        # create webhook
-        $webprofile.create
-        expect($webprofile).to be_an_instance_of(WebProfile)
-        expect($webprofile.name.to_s).to eq($randname)
-      end
-
-      it "List" do
-        list = WebProfile.get_list
-        expect(list.size).to be > 1
-        expect(list.first).to be_an_instance_of(WebProfileList)
-      end
-
-      it "Retrieve" do
-        webprofile = WebProfile.find($webprofile.id)
-        expect(webprofile).to be_an_instance_of(WebProfile)
-        expect(webprofile.name.to_s).to eq($randname)
-      end
-
-      it "Update" do
-        # append "-test" to web profile name
-        webprofile = WebProfile.find($webprofile.id)
-        webprofile.name += "-test"
-        webprofile.update
-
-        # check whether the name was updated
-        webprofile = WebProfile.find($webprofile.id)
-        expect(webprofile.name).to eq($randname + "-test")
-        webprofile.name = $randname
-        webprofile.update
-
-        # revert updated profile name for next test run
-        webprofile = WebProfile.find($webprofile.id)
-        expect(webprofile.name).to eq($randname)
-      end
-
-      it "Partial update" do
-        # retrieve web profile to perform partial update on
-        webprofile = WebProfile.find($webprofile.id)
-
-        # set up partial update
-        h = {"op" => "replace",
-          "path" => "/presentation/brand_name",
-          "value" => "new_brand_name"}
-
-        # do partial update by sending a patch request
-        expect(webprofile.partial_update( [h] )).to be_truthy
-        webprofile = WebProfile.find($webprofile.id)
-        expect(webprofile.presentation.brand_name).to eq("new_brand_name")
-
-        # restore original value for the next test run
-        h = {"op" => "replace",
-          "path" => "/presentation/brand_name",
-          "value" => "brand_name"}
-        expect(webprofile.partial_update( [h] )).to be_truthy
-        expect(WebProfile.find($webprofile.id).presentation.brand_name).to eq("brand_name")
-      end
-
-      it "Delete" do
-        # delete newly created web profile from above create test
-        expect($webprofile.delete).to be_truthy
-
-        # make sure it is not retrieved from the system
-        begin
-          webprofile = WebProfile.find($webprofile.id)
-          expect(webprofile).to be_nil
-          fail "WebProfile with ID=#{$webprofile.id} has not been deleted"
-        rescue ResourceNotFound
-        end
-      end
-    end
-  end
-end