gocardless_pro 2.24.0 → 2.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bac8c2899f9fd824c6dd5f94bcfa506694dc9f97839cb86a1b64149ccfc92e48
-  data.tar.gz: f12c865ed4d9eaa0def7d20fea5e2b15e2c225898de92bee5758d9a6757e476c
+  metadata.gz: 1e1d21b1955fd8db168185745bd1afbd46fd7c3fa434006abf5c0e838cd7507e
+  data.tar.gz: ef057338fc37aa2e791ef3dcd7536a50ff55711e7d8fa5762a51d6797395cab6
 SHA512:
-  metadata.gz: f3c76aad9bbaace084b8449366edc8b1f8b33f0b705e22050137bc3d2c31b43228addbea11943b337e8ac6c0a7da52117979dea6ee8e1e425dbca026d159e467
-  data.tar.gz: '097fd8d09e04a316d2e37010eb78d36b8278e7ec8e9cbed867c772ccf3b522957d1fae644c4357a2b560917a16e90b6284841679c79e8525f8f3324795715139'
+  metadata.gz: 7c1daafd49f92798ff81c407809ecf888429f2c723801c42b49dfe4d7d7351ae818925c46d897784f798c7d4ee2c7089959594cec38ab0fc6df3472f481d0207
+  data.tar.gz: 78eb4cd3154aa14fe50e445cd94605fe39f91893564650948717e84356fb7d374357ecbfad08784be2c21221fc096530e85407c8a1a3eb794b2ab5d40d0024d1

data/lib/gocardless_pro.rb

@@ -77,6 +77,9 @@ require_relative 'gocardless_pro/services/mandate_import_entries_service'
 require_relative 'gocardless_pro/resources/mandate_pdf'
 require_relative 'gocardless_pro/services/mandate_pdfs_service'
 
+require_relative 'gocardless_pro/resources/payer_authorisation'
+require_relative 'gocardless_pro/services/payer_authorisations_service'
+
 require_relative 'gocardless_pro/resources/payment'
 require_relative 'gocardless_pro/services/payments_service'
 

data/lib/gocardless_pro/client.rb

@@ -68,6 +68,11 @@ module GoCardlessPro
       @mandate_pdfs ||= Services::MandatePdfsService.new(@api_service)
     end
 
+    # Access to the service for payer_authorisation to make API calls
+    def payer_authorisations
+      @payer_authorisations ||= Services::PayerAuthorisationsService.new(@api_service)
+    end
+
     # Access to the service for payment to make API calls
     def payments
       @payments ||= Services::PaymentsService.new(@api_service)
@@ -153,7 +158,7 @@ module GoCardlessPro
           'User-Agent' => user_agent.to_s,
           'Content-Type' => 'application/json',
           'GoCardless-Client-Library' => 'gocardless-pro-ruby',
-          'GoCardless-Client-Version' => '2.24.0',
+          'GoCardless-Client-Version' => '2.25.0',
         },
       }
     end

data/lib/gocardless_pro/resources/payer_authorisation.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+#
+# This client is automatically generated from a template and JSON schema definition.
+# See https://github.com/gocardless/gocardless-pro-ruby#contributing before editing.
+#
+
+require 'uri'
+
+module GoCardlessPro
+  # A module containing classes for each of the resources in the GC Api
+  module Resources
+    # Represents an instance of a payer_authorisation resource returned from the API
+
+    # Payer Authorisation resource acts as a wrapper for creating customer, bank
+    # account and mandate details in a single request.
+    # PayerAuthorisation API enables the integrators to build their own custom
+    # payment pages.
+    #
+    # The process to use the Payer Authorisation API is as follows:
+    #
+    #   1. Create a Payer Authorisation, either empty or with already available
+    # information
+    #   2. Update the authorisation with additional information or fix any
+    # mistakes
+    #   3. Submit the authorisation, after the payer has reviewed their
+    # information
+    #   4. [coming soon] Redirect the payer to the verification mechanisms from
+    # the response of the Submit request (this will be introduced as a
+    # non-breaking change)
+    #   5. Confirm the authorisation to indicate that the resources can be
+    # created
+    #
+    # After the Payer Authorisation is confirmed, resources will eventually be
+    # created as it's an asynchronous process.
+    #
+    # To retrieve the status and ID of the linked resources you can do one of
+    # the following:
+    # <ol>
+    #   <li> Listen to <code>  payer_authorisation_completed </code>  <a
+    # href="#appendix-webhooks"> webhook</a> (recommended)</li>
+    #   <li> Poll the GET <a
+    # href="#payer-authorisations-get-a-single-payer-authorisation">
+    # endpoint</a></li>
+    #   <li> Poll the GET events API
+    # <code>https://api.gocardless.com/events?payer_authorisation={id}&action=completed</code>
+    # </li>
+    # </ol>
+    #
+    # <p class="notice">
+    #   Note that the `create` and `update` endpoints behave differently than
+    #   other existing `create` and `update` endpoints. The Payer Authorisation
+    # is still saved if incomplete data is provided.
+    #   We return the list of incomplete data in the `incomplete_fields` along
+    # with the resources in the body of the response.
+    #   <br><br>
+    #   The API is designed to be flexible and allows you to collect information
+    # in multiple steps without storing any sensitive data in the browser or in
+    # your servers.
+    # </p>
+    class PayerAuthorisation
+      attr_reader :bank_account
+      attr_reader :created_at
+      attr_reader :customer
+      attr_reader :id
+      attr_reader :incomplete_fields
+      attr_reader :mandate
+      attr_reader :status
+
+      # Initialize a payer_authorisation resource instance
+      # @param object [Hash] an object returned from the API
+      def initialize(object, response = nil)
+        @object = object
+
+        @bank_account = object['bank_account']
+        @created_at = object['created_at']
+        @customer = object['customer']
+        @id = object['id']
+        @incomplete_fields = object['incomplete_fields']
+        @links = object['links']
+        @mandate = object['mandate']
+        @status = object['status']
+        @response = response
+      end
+
+      def api_response
+        ApiResponse.new(@response)
+      end
+
+      # Return the links that the resource has
+      def links
+        @payer_authorisation_links ||= Links.new(@links)
+      end
+
+      # Provides the payer_authorisation resource as a hash of all its readable attributes
+      def to_h
+        @object
+      end
+
+      class Links
+        def initialize(links)
+          @links = links || {}
+        end
+
+        def bank_account
+          @links['bank_account']
+        end
+
+        def customer
+          @links['customer']
+        end
+
+        def mandate
+          @links['mandate']
+        end
+      end
+    end
+  end
+end

data/lib/gocardless_pro/resources/payout_item.rb

@@ -73,6 +73,10 @@ module GoCardlessPro
         def payment
           @links['payment']
         end
+
+        def refund
+          @links['refund']
+        end
       end
     end
   end

data/lib/gocardless_pro/services/payer_authorisations_service.rb

@@ -0,0 +1,208 @@
+require_relative './base_service'
+
+# encoding: utf-8
+#
+# This client is automatically generated from a template and JSON schema definition.
+# See https://github.com/gocardless/gocardless-pro-ruby#contributing before editing.
+#
+
+module GoCardlessPro
+  module Services
+    # Service for making requests to the PayerAuthorisation endpoints
+    class PayerAuthorisationsService < BaseService
+      # Retrieves the details of a single existing Payer Authorisation. It can be used
+      # for polling the status of a Payer Authorisation.
+      # Example URL: /payer_authorisations/:identity
+      #
+      # @param identity       # Unique identifier, beginning with "PA".
+      # @param options [Hash] parameters as a hash, under a params key.
+      def get(identity, options = {})
+        path = sub_url('/payer_authorisations/:identity', 'identity' => identity)
+
+        options[:retry_failures] = true
+
+        response = make_request(:get, path, options)
+
+        return if response.body.nil?
+
+        Resources::PayerAuthorisation.new(unenvelope_body(response.body), response)
+      end
+
+      # Creates a Payer Authorisation. The resource is saved to the database even if
+      # incomplete. An empty array of incomplete_fields means that the resource is
+      # valid. The ID of the resource is used for the other actions. This endpoint has
+      # been designed this way so you do not need to save any payer data on your
+      # servers or the browser while still being able to implement a progressive
+      # solution, such as a multi-step form.
+      # Example URL: /payer_authorisations
+      # @param options [Hash] parameters as a hash, under a params key.
+      def create(options = {})
+        path = '/payer_authorisations'
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params][envelope_key] = params
+
+        options[:retry_failures] = true
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:body)
+        rescue InvalidStateError => e
+          if e.idempotent_creation_conflict?
+            case @api_service.on_idempotency_conflict
+            when :raise
+              raise IdempotencyConflict, e.error
+            when :fetch
+              return get(e.conflicting_resource_id)
+            else
+              raise ArgumentError, 'Unknown mode for :on_idempotency_conflict'
+            end
+          end
+
+          raise e
+        end
+
+        return if response.body.nil?
+
+        Resources::PayerAuthorisation.new(unenvelope_body(response.body), response)
+      end
+
+      # Updates a Payer Authorisation. Updates the Payer Authorisation with the
+      # request data.Can be invoked as many times as needed. Only fields present in
+      # the request will be modified. An empty array of incomplete_fields means that
+      # the resource is valid. This endpoint has been designed this way so you do not
+      # need to save any payer data on your servers or the browser while still being
+      # able to implement a progressive solution, such a multi-step form. <p
+      # class="notice"> Note that in order to update the `metadata` attribute values
+      # it must be sent completely as it overrides the previously existing values.
+      # </p>
+      # Example URL: /payer_authorisations/:identity
+      #
+      # @param identity       # Unique identifier, beginning with "PA".
+      # @param options [Hash] parameters as a hash, under a params key.
+      def update(identity, options = {})
+        path = sub_url('/payer_authorisations/:identity', 'identity' => identity)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params][envelope_key] = params
+
+        options[:retry_failures] = true
+
+        response = make_request(:put, path, options)
+
+        return if response.body.nil?
+
+        Resources::PayerAuthorisation.new(unenvelope_body(response.body), response)
+      end
+
+      # Submits all the data previously pushed to this PayerAuthorisation for
+      # verification.This time, a 200 HTTP status is returned if the resource is valid
+      # and a 422 error response in case of validation errors. After it is
+      # successfully submitted, the Payer Authorisation can no longer be edited.
+      # Example URL: /payer_authorisations/:identity/actions/submit
+      #
+      # @param identity       # Unique identifier, beginning with "PA".
+      # @param options [Hash] parameters as a hash, under a params key.
+      def submit(identity, options = {})
+        path = sub_url('/payer_authorisations/:identity/actions/submit', 'identity' => identity)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]['data'] = params
+
+        options[:retry_failures] = false
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:body)
+        rescue InvalidStateError => e
+          if e.idempotent_creation_conflict?
+            case @api_service.on_idempotency_conflict
+            when :raise
+              raise IdempotencyConflict, e.error
+            when :fetch
+              return get(e.conflicting_resource_id)
+            else
+              raise ArgumentError, 'Unknown mode for :on_idempotency_conflict'
+            end
+          end
+
+          raise e
+        end
+
+        return if response.body.nil?
+
+        Resources::PayerAuthorisation.new(unenvelope_body(response.body), response)
+      end
+
+      # Confirms the Payer Authorisation, indicating that the resources are ready to
+      # be created.
+      # A Payer Authorisation cannot be confirmed if it hasn't been submitted yet.
+      #
+      # <p class="notice">
+      #   The main use of the confirm endpoint is to enable integrators to acknowledge
+      # the end of the setup process.
+      #   They might want to make the payers go through some other steps after they go
+      # through our flow or make them go through the necessary verification
+      # mechanism(upcomming feature).
+      # </p>
+      # Example URL: /payer_authorisations/:identity/actions/confirm
+      #
+      # @param identity       # Unique identifier, beginning with "PA".
+      # @param options [Hash] parameters as a hash, under a params key.
+      def confirm(identity, options = {})
+        path = sub_url('/payer_authorisations/:identity/actions/confirm', 'identity' => identity)
+
+        params = options.delete(:params) || {}
+        options[:params] = {}
+        options[:params]['data'] = params
+
+        options[:retry_failures] = false
+
+        begin
+          response = make_request(:post, path, options)
+
+          # Response doesn't raise any errors until #body is called
+          response.tap(&:body)
+        rescue InvalidStateError => e
+          if e.idempotent_creation_conflict?
+            case @api_service.on_idempotency_conflict
+            when :raise
+              raise IdempotencyConflict, e.error
+            when :fetch
+              return get(e.conflicting_resource_id)
+            else
+              raise ArgumentError, 'Unknown mode for :on_idempotency_conflict'
+            end
+          end
+
+          raise e
+        end
+
+        return if response.body.nil?
+
+        Resources::PayerAuthorisation.new(unenvelope_body(response.body), response)
+      end
+
+      private
+
+      # Unenvelope the response of the body using the service's `envelope_key`
+      #
+      # @param body [Hash]
+      def unenvelope_body(body)
+        body[envelope_key] || body['data']
+      end
+
+      # return the key which API responses will envelope data under
+      def envelope_key
+        'payer_authorisations'
+      end
+    end
+  end
+end

data/lib/gocardless_pro/version.rb

@@ -4,5 +4,5 @@ end
 
 module GoCardlessPro
   # Current version of the GC gem
-  VERSION = '2.24.0'.freeze
+  VERSION = '2.25.0'.freeze
 end

data/spec/resources/payer_authorisation_spec.rb

@@ -0,0 +1,418 @@
+require 'spec_helper'
+
+describe GoCardlessPro::Resources::PayerAuthorisation do
+  let(:client) do
+    GoCardlessPro::Client.new(
+      access_token: 'SECRET_TOKEN'
+    )
+  end
+
+  let(:response_headers) { { 'Content-Type' => 'application/json' } }
+
+  describe '#get' do
+    let(:id) { 'ID123' }
+
+    subject(:get_response) { client.payer_authorisations.get(id) }
+
+    context 'passing in a custom header' do
+      let!(:stub) do
+        stub_url = '/payer_authorisations/:identity'.gsub(':identity', id)
+        stub_request(:get, /.*api.gocardless.com#{stub_url}/).
+          with(headers: { 'Foo' => 'Bar' }).
+          to_return(
+            body: {
+              'payer_authorisations' => {
+
+                'bank_account' => 'bank_account-input',
+                'created_at' => 'created_at-input',
+                'customer' => 'customer-input',
+                'id' => 'id-input',
+                'incomplete_fields' => 'incomplete_fields-input',
+                'links' => 'links-input',
+                'mandate' => 'mandate-input',
+                'status' => 'status-input',
+              },
+            }.to_json,
+            headers: response_headers
+          )
+      end
+
+      subject(:get_response) do
+        client.payer_authorisations.get(id, headers: {
+                                          'Foo' => 'Bar',
+                                        })
+      end
+
+      it 'includes the header' do
+        get_response
+        expect(stub).to have_been_requested
+      end
+    end
+
+    context 'when there is a payer_authorisation to return' do
+      before do
+        stub_url = '/payer_authorisations/:identity'.gsub(':identity', id)
+        stub_request(:get, /.*api.gocardless.com#{stub_url}/).to_return(
+          body: {
+            'payer_authorisations' => {
+
+              'bank_account' => 'bank_account-input',
+              'created_at' => 'created_at-input',
+              'customer' => 'customer-input',
+              'id' => 'id-input',
+              'incomplete_fields' => 'incomplete_fields-input',
+              'links' => 'links-input',
+              'mandate' => 'mandate-input',
+              'status' => 'status-input',
+            },
+          }.to_json,
+          headers: response_headers
+        )
+      end
+
+      it 'wraps the response in a resource' do
+        expect(get_response).to be_a(GoCardlessPro::Resources::PayerAuthorisation)
+      end
+    end
+
+    context 'when nothing is returned' do
+      before do
+        stub_url = '/payer_authorisations/:identity'.gsub(':identity', id)
+        stub_request(:get, /.*api.gocardless.com#{stub_url}/).to_return(
+          body: '',
+          headers: response_headers
+        )
+      end
+
+      it 'returns nil' do
+        expect(get_response).to be_nil
+      end
+    end
+
+    context "when an ID is specified which can't be included in a valid URI" do
+      let(:id) { '`' }
+
+      it "doesn't raise an error" do
+        expect { get_response }.to_not raise_error(/bad URI/)
+      end
+    end
+  end
+
+  describe '#create' do
+    subject(:post_create_response) { client.payer_authorisations.create(params: new_resource) }
+    context 'with a valid request' do
+      let(:new_resource) do
+        {
+
+          'bank_account' => 'bank_account-input',
+          'created_at' => 'created_at-input',
+          'customer' => 'customer-input',
+          'id' => 'id-input',
+          'incomplete_fields' => 'incomplete_fields-input',
+          'links' => 'links-input',
+          'mandate' => 'mandate-input',
+          'status' => 'status-input',
+        }
+      end
+
+      before do
+        stub_request(:post, %r{.*api.gocardless.com/payer_authorisations}).
+          with(
+            body: {
+              'payer_authorisations' => {
+
+                'bank_account' => 'bank_account-input',
+                'created_at' => 'created_at-input',
+                'customer' => 'customer-input',
+                'id' => 'id-input',
+                'incomplete_fields' => 'incomplete_fields-input',
+                'links' => 'links-input',
+                'mandate' => 'mandate-input',
+                'status' => 'status-input',
+              },
+            }
+          ).
+          to_return(
+            body: {
+              'payer_authorisations' =>
+
+                {
+
+                  'bank_account' => 'bank_account-input',
+                  'created_at' => 'created_at-input',
+                  'customer' => 'customer-input',
+                  'id' => 'id-input',
+                  'incomplete_fields' => 'incomplete_fields-input',
+                  'links' => 'links-input',
+                  'mandate' => 'mandate-input',
+                  'status' => 'status-input',
+                },
+
+            }.to_json,
+            headers: response_headers
+          )
+      end
+
+      it 'creates and returns the resource' do
+        expect(post_create_response).to be_a(GoCardlessPro::Resources::PayerAuthorisation)
+      end
+    end
+
+    context 'with a request that returns a validation error' do
+      let(:new_resource) { {} }
+
+      before do
+        stub_request(:post, %r{.*api.gocardless.com/payer_authorisations}).to_return(
+          body: {
+            error: {
+              type: 'validation_failed',
+              code: 422,
+              errors: [
+                { message: 'test error message', field: 'test_field' },
+              ],
+            },
+          }.to_json,
+          headers: response_headers,
+          status: 422
+        )
+      end
+
+      it 'throws the correct error' do
+        expect { post_create_response }.to raise_error(GoCardlessPro::ValidationError)
+      end
+    end
+
+    context 'with a request that returns an idempotent creation conflict error' do
+      let(:id) { 'ID123' }
+
+      let(:new_resource) do
+        {
+
+          'bank_account' => 'bank_account-input',
+          'created_at' => 'created_at-input',
+          'customer' => 'customer-input',
+          'id' => 'id-input',
+          'incomplete_fields' => 'incomplete_fields-input',
+          'links' => 'links-input',
+          'mandate' => 'mandate-input',
+          'status' => 'status-input',
+        }
+      end
+
+      let!(:post_stub) do
+        stub_request(:post, %r{.*api.gocardless.com/payer_authorisations}).to_return(
+          body: {
+            error: {
+              type: 'invalid_state',
+              code: 409,
+              errors: [
+                {
+                  message: 'A resource has already been created with this idempotency key',
+                  reason: 'idempotent_creation_conflict',
+                  links: {
+                    conflicting_resource_id: id,
+                  },
+                },
+              ],
+            },
+          }.to_json,
+          headers: response_headers,
+          status: 409
+        )
+      end
+
+      let!(:get_stub) do
+        stub_url = "/payer_authorisations/#{id}"
+        stub_request(:get, /.*api.gocardless.com#{stub_url}/).
+          to_return(
+            body: {
+              'payer_authorisations' => {
+
+                'bank_account' => 'bank_account-input',
+                'created_at' => 'created_at-input',
+                'customer' => 'customer-input',
+                'id' => 'id-input',
+                'incomplete_fields' => 'incomplete_fields-input',
+                'links' => 'links-input',
+                'mandate' => 'mandate-input',
+                'status' => 'status-input',
+              },
+            }.to_json,
+            headers: response_headers
+          )
+      end
+
+      it 'fetches the already-created resource' do
+        post_create_response
+        expect(post_stub).to have_been_requested
+        expect(get_stub).to have_been_requested
+      end
+    end
+  end
+
+  describe '#update' do
+    subject(:put_update_response) { client.payer_authorisations.update(id, params: update_params) }
+    let(:id) { 'ABC123' }
+
+    context 'with a valid request' do
+      let(:update_params) { { 'hello' => 'world' } }
+
+      let!(:stub) do
+        stub_url = '/payer_authorisations/:identity'.gsub(':identity', id)
+        stub_request(:put, /.*api.gocardless.com#{stub_url}/).to_return(
+          body: {
+            'payer_authorisations' => {
+
+              'bank_account' => 'bank_account-input',
+              'created_at' => 'created_at-input',
+              'customer' => 'customer-input',
+              'id' => 'id-input',
+              'incomplete_fields' => 'incomplete_fields-input',
+              'links' => 'links-input',
+              'mandate' => 'mandate-input',
+              'status' => 'status-input',
+            },
+          }.to_json,
+          headers: response_headers
+        )
+      end
+
+      it 'updates and returns the resource' do
+        expect(put_update_response).to be_a(GoCardlessPro::Resources::PayerAuthorisation)
+        expect(stub).to have_been_requested
+      end
+    end
+  end
+
+  describe '#submit' do
+    subject(:post_response) { client.payer_authorisations.submit(resource_id) }
+
+    let(:resource_id) { 'ABC123' }
+
+    let!(:stub) do
+      # /payer_authorisations/%v/actions/submit
+      stub_url = '/payer_authorisations/:identity/actions/submit'.gsub(':identity', resource_id)
+      stub_request(:post, /.*api.gocardless.com#{stub_url}/).to_return(
+        body: {
+          'payer_authorisations' => {
+
+            'bank_account' => 'bank_account-input',
+            'created_at' => 'created_at-input',
+            'customer' => 'customer-input',
+            'id' => 'id-input',
+            'incomplete_fields' => 'incomplete_fields-input',
+            'links' => 'links-input',
+            'mandate' => 'mandate-input',
+            'status' => 'status-input',
+          },
+        }.to_json,
+        headers: response_headers
+      )
+    end
+
+    it 'wraps the response and calls the right endpoint' do
+      expect(post_response).to be_a(GoCardlessPro::Resources::PayerAuthorisation)
+
+      expect(stub).to have_been_requested
+    end
+
+    context 'when the request needs a body and custom header' do
+      let(:body) { { foo: 'bar' } }
+      let(:headers) { { 'Foo' => 'Bar' } }
+      subject(:post_response) { client.payer_authorisations.submit(resource_id, body, headers) }
+
+      let(:resource_id) { 'ABC123' }
+
+      let!(:stub) do
+        # /payer_authorisations/%v/actions/submit
+        stub_url = '/payer_authorisations/:identity/actions/submit'.gsub(':identity', resource_id)
+        stub_request(:post, /.*api.gocardless.com#{stub_url}/).
+          with(
+            body: { foo: 'bar' },
+            headers: { 'Foo' => 'Bar' }
+          ).to_return(
+            body: {
+              'payer_authorisations' => {
+
+                'bank_account' => 'bank_account-input',
+                'created_at' => 'created_at-input',
+                'customer' => 'customer-input',
+                'id' => 'id-input',
+                'incomplete_fields' => 'incomplete_fields-input',
+                'links' => 'links-input',
+                'mandate' => 'mandate-input',
+                'status' => 'status-input',
+              },
+            }.to_json,
+            headers: response_headers
+          )
+      end
+    end
+  end
+
+  describe '#confirm' do
+    subject(:post_response) { client.payer_authorisations.confirm(resource_id) }
+
+    let(:resource_id) { 'ABC123' }
+
+    let!(:stub) do
+      # /payer_authorisations/%v/actions/confirm
+      stub_url = '/payer_authorisations/:identity/actions/confirm'.gsub(':identity', resource_id)
+      stub_request(:post, /.*api.gocardless.com#{stub_url}/).to_return(
+        body: {
+          'payer_authorisations' => {
+
+            'bank_account' => 'bank_account-input',
+            'created_at' => 'created_at-input',
+            'customer' => 'customer-input',
+            'id' => 'id-input',
+            'incomplete_fields' => 'incomplete_fields-input',
+            'links' => 'links-input',
+            'mandate' => 'mandate-input',
+            'status' => 'status-input',
+          },
+        }.to_json,
+        headers: response_headers
+      )
+    end
+
+    it 'wraps the response and calls the right endpoint' do
+      expect(post_response).to be_a(GoCardlessPro::Resources::PayerAuthorisation)
+
+      expect(stub).to have_been_requested
+    end
+
+    context 'when the request needs a body and custom header' do
+      let(:body) { { foo: 'bar' } }
+      let(:headers) { { 'Foo' => 'Bar' } }
+      subject(:post_response) { client.payer_authorisations.confirm(resource_id, body, headers) }
+
+      let(:resource_id) { 'ABC123' }
+
+      let!(:stub) do
+        # /payer_authorisations/%v/actions/confirm
+        stub_url = '/payer_authorisations/:identity/actions/confirm'.gsub(':identity', resource_id)
+        stub_request(:post, /.*api.gocardless.com#{stub_url}/).
+          with(
+            body: { foo: 'bar' },
+            headers: { 'Foo' => 'Bar' }
+          ).to_return(
+            body: {
+              'payer_authorisations' => {
+
+                'bank_account' => 'bank_account-input',
+                'created_at' => 'created_at-input',
+                'customer' => 'customer-input',
+                'id' => 'id-input',
+                'incomplete_fields' => 'incomplete_fields-input',
+                'links' => 'links-input',
+                'mandate' => 'mandate-input',
+                'status' => 'status-input',
+              },
+            }.to_json,
+            headers: response_headers
+          )
+      end
+    end
+  end
+end