defra_ruby_mocks 5.0.0 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a608d402c9667f9aef72c67f4ae1edf115d0385b4315e37e6c926d1c79d92958
-  data.tar.gz: 2d8f253849caf74c2486777e82f2c5406bde65725d14078271452df3afdaab98
+  metadata.gz: 9a54f9624d84a56d58fb86ff1a7556d5d7c88db8cd4c93106c260e1b14008c38
+  data.tar.gz: 020561b363c345fa55dc26a27b9cc5bbe4306a5c5743ef824d095463b8e80e12
 SHA512:
-  metadata.gz: b4550088184172df4cf64516baa91a60ae1f6fd496cb2a3d8dbbe9c3375dc1afc73e2dbea191217d059c34773d73de56cc4b5c8c854a1b1cb47869ca8cc8bd22
-  data.tar.gz: ec7ca0077154ced7847aa76947403b2a994a7b3f2460bc1451755abc4e31f16ed30407ca1c60588f1d04f66c28b9b075c6d64abdcf7021b7ad18775323d85faf
+  metadata.gz: 60761ea8c403d69d31ef96d890d37b90013b26e0dc0cd271ef7b5a3efb933225d3fb75178dc3aae3f8715088e1fe2e26344118668bed43cee9f44b901c0071e9
+  data.tar.gz: d6c620d9805c12b864727a0f6d7b52356a18925858f8ef11c6e44889764f317d52379146c3fc25adede7e06c8c04e814fd8990b03d57816f4604bf70db7d9490

data/app/controllers/concerns/defra_ruby_mocks/can_use_aws_s3.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module DefraRubyMocks
+  module CanUseAwsS3
+
+    extend ActiveSupport::Concern
+
+    DEFAULT_LAST_REFUND_REQUEST_TIME = 1.day.ago.freeze
+
+    included do
+
+      def s3_bucket_name
+        @s3_bucket_name ||= ENV.fetch("AWS_DEFRA_RUBY_MOCKS_BUCKET", nil)
+      end
+
+      def set_response_status(response_status_filename:, status:)
+        Rails.logger.info "[DefraRubyMocks] [AwsS3] Setting #{response_status_filename} status to \"#{status}\""
+
+        AwsBucketService.write(s3_bucket_name, response_status_filename, status)
+      end
+
+      # Check whether a non-default status value has been requested
+      def response_status(response_status_filename:, default_status:)
+        status = AwsBucketService.read(s3_bucket_name, response_status_filename)
+        Rails.logger.warn "[DefraRubyMocks] [AwsS3] read #{response_status_filename}: \"#{status}\""
+
+        status || default_status
+      rescue StandardError => e
+        # This is expected behaviour when the status default override file is not present.
+        Rails.logger.warn "[DefraRubyMocks] [AwsS3] failed to read #{response_status_filename}: #{e}"
+
+        default_status
+      end
+
+      # let the refund details service know how long since the refund was requested
+      def write_refund_requested_timestamp(timestamp_file_name:)
+        Rails.logger.warn "[DefraRubyMocks] [AwsS3] storing timestamp_file_name timestamp"
+        AwsBucketService.write(s3_bucket_name, timestamp_file_name, Time.zone.now.to_s)
+      end
+
+      def refund_request_timestamp(timestamp_file_name:)
+        timestamp = AwsBucketService.read(s3_bucket_name, timestamp_file_name)
+        timestamp ? Time.parse(timestamp) : DEFAULT_LAST_REFUND_REQUEST_TIME
+      rescue StandardError
+        DEFAULT_LAST_REFUND_REQUEST_TIME
+      end
+    end
+  end
+end

data/app/controllers/defra_ruby_mocks/govpay_controller.rb

@@ -3,6 +3,8 @@
 module DefraRubyMocks
   class GovpayController < ::DefraRubyMocks::ApplicationController
 
+    include CanUseAwsS3
+
     skip_before_action :verify_authenticity_token
 
     def create_payment
@@ -14,7 +16,7 @@ module DefraRubyMocks
         amount: params[:amount], description: params[:description]
       )
     rescue StandardError => e
-      Rails.logger.error("MOCKS: Govpay payment creation error: #{e.message}")
+      Rails.logger.error("[DefraRubyMocks] [create_payment] error: #{e}")
       head 500
     end
 
@@ -23,12 +25,12 @@ module DefraRubyMocks
     # straight to the application callback route.
     def next_url
       response_url = retrieve_return_url
-      Rails.logger.warn "Govpay mock calling response URL #{response_url}"
+      Rails.logger.warn "[DefraRubyMocks] [Govpay] calling response URL #{response_url}"
       redirect_to response_url, allow_other_host: true
     rescue RestClient::ExceptionWithResponse => e
-      Rails.logger.warn "Govpay mock: RestClient received response: #{e}"
+      Rails.logger.warn "[DefraRubyMocks] [Govpay] RestClient received response: #{e}"
     rescue StandardError => e
-      Rails.logger.error("Govpay mock: Error sending request to govpay: #{e}")
+      Rails.logger.error("[DefraRubyMocks] [Govpay] Error sending request to govpay: #{e}")
       Airbrake.notify(e, message: "Error on govpay request")
     end
 
@@ -36,7 +38,7 @@ module DefraRubyMocks
       valid_payment_id
       render json: GovpayGetPaymentService.new.run(payment_id: params[:payment_id])
     rescue StandardError => e
-      Rails.logger.error("MOCKS: Govpay payment details error: #{e.message}")
+      Rails.logger.error("[DefraRubyMocks] [payment_details] error: #{e}")
       head 422
     end
 
@@ -46,36 +48,32 @@ module DefraRubyMocks
                                                       amount: params[:amount],
                                                       refund_amount_available: params[:refund_amount_available])
     rescue StandardError => e
-      Rails.logger.error("MOCKS: Govpay refund error: #{e.message}")
+      Rails.logger.error("[DefraRubyMocks] [create_refund] error: #{e}")
       head 500
     end
 
     def refund_details
       render json: GovpayRefundDetailsService.new.run(payment_id: params[:payment_id], refund_id: params[:refund_id])
     rescue StandardError => e
-      Rails.logger.error("MOCKS: Govpay refund error: #{e.message}")
+      Rails.logger.error("[DefraRubyMocks] [refund_details] error: #{e}")
       head 500
     end
 
     private
 
-    def s3_bucket_name
-      @s3_bucket_name = ENV.fetch("AWS_DEFRA_RUBY_MOCKS_BUCKET", nil)
-    end
-
     def return_url_file_name
-      @return_url_file_name = "return_url_file"
+      @return_url_file_name ||= "return_url_file"
     end
 
     # We need to persist the return_url between the initial payment creation request and the execution of next_url.
     # We can't use tmp for multi-server environments so we load the temp file to AWS S3.
     def store_return_url(return_url)
-      Rails.logger.warn ":::::: storing return_url #{return_url}"
+      Rails.logger.warn "[DefraRubyMocks] [store_return_url] #{return_url}"
       AwsBucketService.write(s3_bucket_name, return_url_file_name, return_url)
     end
 
     def retrieve_return_url
-      AwsBucketService.read(s3_bucket_name, return_url_file_name)
+      @retrieve_return_url ||= AwsBucketService.read(s3_bucket_name, return_url_file_name)
     end
 
     def valid_create_params

data/app/controllers/defra_ruby_mocks/govpay_test_helpers_controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class GovpayTestHelpersController < ::DefraRubyMocks::ApplicationController
+
+    skip_before_action :verify_authenticity_token
+
+    include CanUseAwsS3
+
+    # These are helpers for the automated acceptance tests.
+
+    # The mock will use the value passed in to populate the status field on all future payments.
+    def set_test_payment_response_status
+      set_response_status(response_status_filename: "test_payment_response_status", status: params[:status])
+
+      head 200
+    end
+
+    # The mock will use the value passed in to populate the status field on all future refunds.
+    def set_test_refund_response_status
+      set_response_status(response_status_filename: "test_refund_response_status", status: params[:status])
+
+      head 200
+    end
+
+    # This schedules a job to send a mock payment webhook.
+    def send_payment_webhook
+      Rails.logger.warn "[DefraRubyMocks] [send_payment_webhook] " \
+                        "params: #{params[:govpay_id]}, status #{params[:payment_status]}"
+
+      %w[govpay_id payment_status callback_url signing_secret].each do |p|
+        raise StandardError, "Missing parameter: '#{p}'" unless params[p].present?
+      end
+
+      SendPaymentWebhookJob.perform_later(
+        govpay_id: params[:govpay_id],
+        status: params[:payment_status],
+        callback_url: params[:callback_url],
+        signing_secret: params[:signing_secret]
+      )
+
+      head 200
+    end
+
+    # This schedules a job to send a mock refund webhook.
+    def send_refund_webhook
+      Rails.logger.warn "[DefraRubyMocks] [send_refund webhook] " \
+                        "params: #{params[:govpay_id]}, status #{params[:refund_status]}"
+
+      %w[govpay_id refund_status callback_url signing_secret].each do |p|
+        raise StandardError, "Missing parameter: '#{p}'" unless params[p].present?
+      end
+
+      SendRefundWebhookJob.perform_later(
+        govpay_id: params[:govpay_id],
+        status: params[:refund_status],
+        callback_url: params[:callback_url],
+        signing_secret: params[:signing_secret]
+      )
+
+      head 200
+    end
+
+    private
+
+    def s3_bucket_name
+      @s3_bucket_name = ENV.fetch("AWS_DEFRA_RUBY_MOCKS_BUCKET", nil)
+    end
+  end
+end

data/app/jobs/application_job.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationJob < ActiveJob::Base
+  queue_as :default
+end

data/app/jobs/base_send_webhook_job.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class BaseSendWebhookJob < ApplicationJob
+  def perform(govpay_id:, status:, callback_url:, signing_secret:)
+    body = webhook_body(govpay_id:, status:)
+    Rails.logger.warn "[DefraRubyMocks] [BaseSendWebhookJob] sending #{webhook_type} webhook " \
+                      "for #{govpay_id}, status \"#{status}\" to #{callback_url}"
+    RestClient::Request.execute(
+      method: :get,
+      url: callback_url,
+      body: body,
+      headers: { "Pay-Signature": webhook_signature(body, signing_secret) }
+    )
+  rescue StandardError => e
+    Rails.logger.error "[DefraRubyMocks] [BaseSendWebhookJob] error sending  " \
+                       "#{webhook_type} webhook to #{callback_url}: #{e}"
+  end
+
+  private
+
+  def webhook_type
+    raise NotImplementedError
+  end
+
+  def webhook_body(govpay_id:, status:)
+    raise NotImplementedError
+  end
+
+  def webhook_signature(webhook_body, signing_secret)
+    OpenSSL::HMAC.hexdigest("sha256", signing_secret.encode("utf-8"), webhook_body.to_json.encode("utf-8"))
+  end
+
+end

data/app/jobs/send_payment_webhook_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class SendPaymentWebhookJob < BaseSendWebhookJob
+
+  private
+
+  def webhook_type
+    "payment"
+  end
+
+  def webhook_body(govpay_id:, status:)
+    webhook_body ||= JSON.parse(File.read("lib/fixtures/files/govpay/webhook_payment_update_body.json"))
+
+    webhook_body["resource"]["payment_id"] = govpay_id
+    webhook_body["resource"]["state"]["status"] = status
+
+    webhook_body
+  end
+end

data/app/jobs/send_refund_webhook_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class SendRefundWebhookJob < BaseSendWebhookJob
+
+  private
+
+  def webhook_type
+    "refund"
+  end
+
+  def webhook_body(govpay_id:, status:)
+    webhook_body ||= JSON.parse(File.read("lib/fixtures/files/govpay/webhook_refund_update_body.json"))
+
+    webhook_body["payment_id"] = govpay_id
+    webhook_body["status"] = status
+
+    webhook_body
+  end
+end

data/app/services/defra_ruby_mocks/aws_bucket_service.rb

@@ -16,10 +16,15 @@ module DefraRubyMocks
       new.read(bucket_name, file_name)
     end
 
+    def self.remove(bucket_name, file_name)
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] removing #{file_name} on S3"
+      new.remove(bucket_name, file_name)
+    end
+
     def write(bucket_name, file_name, content)
       @bucket_name = bucket_name
       @file_name = file_name
-      Rails.logger.debug ":::::: mocks writing to S3"
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] writing #{file_name} to S3"
 
       write_temp_file(content)
 
@@ -31,31 +36,41 @@ module DefraRubyMocks
     def read(bucket_name, file_name)
       @bucket_name = bucket_name
       @file_name = file_name
-      Rails.logger.debug ":::::: mocks reading from S3"
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] reading #{file_name} from S3"
+
+      s3.get_object(bucket: bucket_name, key: file_name).body.read
+    end
+
+    def remove(bucket_name, file_name)
+      @bucket_name = bucket_name
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] removing #{file_name} from S3"
 
-      s3 = Aws::S3::Client.new(
+      bucket.delete(file_name)
+    end
+
+    private
+
+    def s3
+      @s3 ||= Aws::S3::Client.new(
         region: ENV.fetch("AWS_REGION", nil),
         credentials: Aws::Credentials.new(
           ENV.fetch("AWS_DEFRA_RUBY_MOCKS_ACCESS_KEY_ID", nil),
           ENV.fetch("AWS_DEFRA_RUBY_MOCKS_SECRET_ACCESS_KEY", nil)
         )
       )
-      s3.get_object(bucket: bucket_name, key: file_name).body.read
     end
 
-    private
-
     def temp_filepath
       "#{Dir.tmpdir}/#{file_name}"
     end
 
     def write_temp_file(content)
-      Rails.logger.debug ":::::: mocks creating temp file for #{content}"
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] creating temp file for \"#{content}\""
       File.write(temp_filepath, content)
     end
 
     def load_temp_file_to_s3
-      Rails.logger.debug ":::::: mocks loading temp file to S3 bucket #{bucket_name}"
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] loading temp file to S3 bucket #{bucket_name}"
 
       result = nil
 

data/app/services/defra_ruby_mocks/govpay_create_payment_service.rb

@@ -5,6 +5,8 @@ require "securerandom"
 module DefraRubyMocks
   class GovpayCreatePaymentService < BaseService
 
+    include CanUseAwsS3
+
     def run(amount:, description:)
       success_response.merge(
         {
@@ -21,6 +23,10 @@ module DefraRubyMocks
 
     private
 
+    def test_payment_response_status
+      response_status(response_status_filename: "test_payment_response_status", default_status: "created")
+    end
+
     def base_url
       File.join(DefraRubyMocks.configuration.govpay_domain, "/payments")
     end
@@ -34,7 +40,7 @@ module DefraRubyMocks
       {
         created_date: "2020-03-03T16:17:19.554Z",
         state: {
-          status: "created",
+          status: test_payment_response_status,
           finished: false
         },
         _links: {

data/app/services/defra_ruby_mocks/govpay_get_payment_service.rb

@@ -5,6 +5,8 @@ require "securerandom"
 module DefraRubyMocks
   class GovpayGetPaymentService < BaseService
 
+    include CanUseAwsS3
+
     def run(payment_id:, amount: Random.rand(100..1_000), created_at: Time.current)
       # This currently supports only success results:
       response_success.merge(
@@ -19,6 +21,10 @@ module DefraRubyMocks
 
     private
 
+    def test_payment_response_status
+      response_status(response_status_filename: "test_payment_response_status", default_status: "success")
+    end
+
     # rubocop:disable Metrics/MethodLength
     def response_success
       {
@@ -32,7 +38,7 @@ module DefraRubyMocks
         },
         email: "sherlock.holmes@example.com",
         state: {
-          status: "success",
+          status: test_payment_response_status,
           finished: true
         },
         payment_id: "cnnffa1e6s3u9a6n24u2cp527d",

data/app/services/defra_ruby_mocks/govpay_refund_details_service.rb

@@ -3,7 +3,7 @@
 module DefraRubyMocks
   class GovpayRefundDetailsService < BaseService
 
-    DEFAULT_LAST_REFUND_REQUEST_TIME = 1.day.ago.freeze
+    include CanUseAwsS3
 
     def run(payment_id:, refund_id:) # rubocop:disable Lint/UnusedMethodArgument
       {
@@ -19,40 +19,28 @@ module DefraRubyMocks
 
     private
 
-    # "submitted" for up to GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG seconds after the last refund request, then "success"
+    # Check if a non-default status value has been requested
+    def test_refund_response_status
+      response_status(response_status_filename: "test_refund_response_status", default_status: "submitted")
+    end
+
+    # "submitted" (or other, if default override is in place) for up to GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG
+    # seconds after the last refund request, then "success"
     def status
-      last_refund_time = refund_request_timestamp
+      last_refund_time = refund_request_timestamp(timestamp_file_name:)
       submitted_success_lag = ENV.fetch("GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG", 0).to_i
       cutoff_time = (last_refund_time + submitted_success_lag.seconds).to_time
       return "success" if submitted_success_lag.zero?
 
-      Time.zone.now < cutoff_time ? "submitted" : "success"
+      Time.zone.now < cutoff_time ? test_refund_response_status : "success"
     rescue Errno::ENOENT
-      write_timestamp_file
+      write_refund_requested_timestamp(timestamp_file_name:)
 
       "success"
     end
 
-    def write_timestamp_file
-      timestamp = Time.zone.now
-      Rails.logger.warn ":::::: writing timestamp file: #{timestamp}"
-      AwsBucketService.write(s3_bucket_name, timestamp_file_name, timestamp)
-    end
-
-    def s3_bucket_name
-      @s3_bucket_name = ENV.fetch("AWS_DEFRA_RUBY_MOCKS_BUCKET", nil)
-    end
-
     def timestamp_file_name
       @govpay_request_refund_service_last_run_time = "govpay_request_refund_service_last_run_time"
     end
-
-    def refund_request_timestamp
-      timestamp = AwsBucketService.read(s3_bucket_name, timestamp_file_name)
-      timestamp ? Time.parse(timestamp) : DEFAULT_LAST_REFUND_REQUEST_TIME
-    rescue StandardError
-      DEFAULT_LAST_REFUND_REQUEST_TIME
-    end
-
   end
 end

data/app/services/defra_ruby_mocks/govpay_request_refund_service.rb

@@ -3,28 +3,23 @@
 module DefraRubyMocks
   class GovpayRequestRefundService < BaseService
 
+    include CanUseAwsS3
+
     def run(payment_id:, amount:, refund_amount_available:) # rubocop:disable Lint/UnusedMethodArgument
-      write_timestamp
+      write_refund_requested_timestamp(timestamp_file_name:)
 
-      # This currently supports only "submitted" status:
       {
         amount: amount,
         created_date: "2019-09-19T16:53:03.213Z",
         refund_id: SecureRandom.hex(22),
-        status: "submitted"
+        status: test_refund_response_status
       }
     end
 
     private
 
-    # let the refund details service know how long since the refund was requested
-    def write_timestamp
-      Rails.logger.warn ":::::: storing refund request timestamp"
-      AwsBucketService.write(s3_bucket_name, timestamp_file_name, Time.zone.now.to_s)
-    end
-
-    def s3_bucket_name
-      @s3_bucket_name = ENV.fetch("AWS_DEFRA_RUBY_MOCKS_BUCKET", nil)
+    def test_refund_response_status
+      response_status(response_status_filename: "test_refund_response_status", default_status: "submitted")
     end
 
     def timestamp_file_name

data/config/routes.rb

@@ -35,4 +35,25 @@ DefraRubyMocks::Engine.routes.draw do # rubocop:disable Metrics/BlockLength
       to: "govpay#refund_details",
       as: "govpay_refund_details",
       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
+
+  # test helpers, not mocks:
+  get "/govpay/v1/payments/set_test_payment_response_status/:status",
+      to: "govpay_test_helpers#set_test_payment_response_status",
+      as: "govpay_set_test_payment_response_status",
+      constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
+
+  get "/govpay/v1/payments/set_test_refund_response_status/:status",
+      to: "govpay_test_helpers#set_test_refund_response_status",
+      as: "govpay_set_test_refund_response_status",
+      constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
+
+  post "/govpay/v1/payments/:govpay_id/send_payment_webhook",
+       to: "govpay_test_helpers#send_payment_webhook",
+       as: "send_payment_webhook",
+       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
+
+  post "/govpay/v1/payments/:govpay_id/send_refund_webhook",
+       to: "govpay_test_helpers#send_refund_webhook",
+       as: "send_refund_webhook",
+       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
 end

data/lib/defra_ruby_mocks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DefraRubyMocks
-  VERSION = "5.0.0"
+  VERSION = "5.1.1"
 end

data/lib/fixtures/files/govpay/webhook_payment_update_body.json

@@ -0,0 +1,48 @@
+{
+    "webhook_message_id": "123abc",
+    "api_version": 1,
+    "created_date": "2019-07-11T10:36:26.988Z",
+    "resource_id": "hu20sqlact5260q2nanm0q8u93",
+    "resource_type": "payment",
+    "event_type": "card_payment_captured",
+    "resource": {
+      "amount": 5000,
+      "description": "Pay your council tax",
+      "reference": "12345",
+      "language": "en",
+      "email": "sherlock.holmes@example.com",
+      "state": {
+        "status": "success",
+        "finished": false
+      },
+      "payment_id": "hu20sqlact5260q2nanm0q8u93",
+      "payment_provider": "stripe",
+      "created_date": "2021-10-19T10:05:45.454Z",
+      "refund_summary": {
+        "status": "pending",
+        "amount_available": 5000,
+        "amount_submitted": 0
+      },
+      "settlement_summary": {},
+      "card_details": {
+        "last_digits_card_number": "1234",
+        "first_digits_card_number": "123456",
+        "cardholder_name": "Sherlock Holmes",
+        "expiry_date": "04/24",
+        "billing_address": {
+          "line1": "221 Baker Street",
+          "line2": "Flat b",
+          "postcode": "NW1 6XE",
+          "city": "London",
+          "country": "GB"
+        },
+        "card_brand": "Visa",
+        "card_type": "debit"
+      },
+      "delayed_capture": false,
+      "moto": false,
+      "provider_id": "10987654321",
+      "return_url": "https://your.service.gov.uk/completed"
+    }
+  }
+  

data/lib/fixtures/files/govpay/webhook_refund_update_body.json

@@ -0,0 +1,8 @@
+{
+    "refund_id": "345",
+    "created_date": "2022-01-26T16:52:41.178Z",
+    "amount": 2000,
+    "status": "success",
+    "settlement_summary": {},
+    "payment_id": "789"
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defra_ruby_mocks
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.1
 platform: ruby
 authors:
 - Defra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-26 00:00:00.000000000 Z
+date: 2025-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: A Rails engine which can be used to mock external services when loaded
   into an application
 email:
@@ -77,9 +91,15 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/controllers/concerns/defra_ruby_mocks/can_use_aws_s3.rb
 - app/controllers/defra_ruby_mocks/application_controller.rb
 - app/controllers/defra_ruby_mocks/company_controller.rb
 - app/controllers/defra_ruby_mocks/govpay_controller.rb
+- app/controllers/defra_ruby_mocks/govpay_test_helpers_controller.rb
+- app/jobs/application_job.rb
+- app/jobs/base_send_webhook_job.rb
+- app/jobs/send_payment_webhook_job.rb
+- app/jobs/send_refund_webhook_job.rb
 - app/services/defra_ruby_mocks/aws_bucket_service.rb
 - app/services/defra_ruby_mocks/base_service.rb
 - app/services/defra_ruby_mocks/companies_house_service.rb
@@ -97,6 +117,8 @@ files:
 - lib/defra_ruby_mocks/invalid_config_error.rb
 - lib/defra_ruby_mocks/missing_resource_error.rb
 - lib/defra_ruby_mocks/version.rb
+- lib/fixtures/files/govpay/webhook_payment_update_body.json
+- lib/fixtures/files/govpay/webhook_refund_update_body.json
 - lib/tasks/changelog.rake
 - lib/tasks/defra_ruby_mocks_tasks.rake
 homepage: https://github.com/DEFRA/defra-ruby-mocks