defra_ruby_mocks 5.1.0 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f12b1df78280f62fd050fc87d169a323a5596e170a3f4908d6e98eac105bbd35
-  data.tar.gz: c01fdde1d3574ad5c12fc89256ae31af9fb326a96d505410f5b3d3189b62f003
+  metadata.gz: 9a54f9624d84a56d58fb86ff1a7556d5d7c88db8cd4c93106c260e1b14008c38
+  data.tar.gz: 020561b363c345fa55dc26a27b9cc5bbe4306a5c5743ef824d095463b8e80e12
 SHA512:
-  metadata.gz: fe25184586116d837320be07f712f56c47c9728c906b6d7a43ceddd908614fffae27fd5a408181633f90c20a50818fa2cee11f0c6e3a6c6dac19707dced20a76
-  data.tar.gz: 1d54bd00a0bca62769bc1b91c27a2521b27de9cce062905787e7cec8c72d58297805a48700de041a287db7aebc21a77bd305484cbfca617eb43860a900de83dd
+  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

@@ -5,29 +5,29 @@ module DefraRubyMocks
 
     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
-      Rails.logger.info "MOCKS: Setting payment response status to #{params[:status]}"
-
-      AwsBucketService.write(s3_bucket_name, "test_payment_response_status", params[: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
-      Rails.logger.info "MOCKS: Setting refund response status to #{params[:status]}"
-
-      AwsBucketService.write(s3_bucket_name, "test_refund_response_status", params[: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 "MOCKS: Sending payment webhook for #{params[:govpay_id]}, status #{params[:payment_status]}"
+      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
@@ -44,7 +44,9 @@ module DefraRubyMocks
 
     # This schedules a job to send a mock refund webhook.
     def send_refund_webhook
-      Rails.logger.warn "MOCKS: Sending refund webhook for #{params[:govpay_id]}, status #{params[:refund_status]}"
+      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

data/app/jobs/base_send_webhook_job.rb

@@ -3,7 +3,8 @@
 class BaseSendWebhookJob < ApplicationJob
   def perform(govpay_id:, status:, callback_url:, signing_secret:)
     body = webhook_body(govpay_id:, status:)
-    Rails.logger.warn "MOCKS: sending #{webhook_type} webhook for #{govpay_id}, status \"#{status}\" to #{callback_url}"
+    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,
@@ -11,7 +12,8 @@ class BaseSendWebhookJob < ApplicationJob
       headers: { "Pay-Signature": webhook_signature(body, signing_secret) }
     )
   rescue StandardError => e
-    Rails.logger.error "MOCKS: error sending #{webhook_type} webhook to #{callback_url}: #{e}\n#{e.backtrace}"
+    Rails.logger.error "[DefraRubyMocks] [BaseSendWebhookJob] error sending  " \
+                       "#{webhook_type} webhook to #{callback_url}: #{e}"
   end
 
   private

data/app/services/defra_ruby_mocks/aws_bucket_service.rb

@@ -17,14 +17,14 @@ module DefraRubyMocks
     end
 
     def self.remove(bucket_name, file_name)
-      Rails.logger.debug ":::::: mocks removing #{file_name} on S3"
+      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 #{file_name} to S3"
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] writing #{file_name} to S3"
 
       write_temp_file(content)
 
@@ -36,14 +36,14 @@ module DefraRubyMocks
     def read(bucket_name, file_name)
       @bucket_name = bucket_name
       @file_name = file_name
-      Rails.logger.debug ":::::: mocks reading #{file_name} 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 ":::::: mocks removing #{file_name} from S3"
+      Rails.logger.debug "[DefraRubyMocks] [AwsBucketService] removing #{file_name} from S3"
 
       bucket.delete(file_name)
     end
@@ -65,12 +65,12 @@ module DefraRubyMocks
     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,17 +23,8 @@ module DefraRubyMocks
 
     private
 
-    def s3_bucket_name
-      @s3_bucket_name = ENV.fetch("AWS_DEFRA_RUBY_MOCKS_BUCKET", nil)
-    end
-
-    # Check if a non-default status value has been requested
     def test_payment_response_status
-      AwsBucketService.read(s3_bucket_name, "test_payment_response_status") || "created"
-    rescue StandardError => e
-      # This is expected behaviour when the payment status default override file is not present.
-      Rails.logger.warn ":::::: mocks failed to read test_payment_response_status: #{e}"
-      "created"
+      response_status(response_status_filename: "test_payment_response_status", default_status: "created")
     end
 
     def base_url

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,13 +21,8 @@ module DefraRubyMocks
 
     private
 
-    # Check if a non-default status value has been requested
     def test_payment_response_status
-      AwsBucketService.read(s3_bucket_name, "test_payment_response_status") || "success"
-    rescue StandardError => e
-      # This is expected behaviour when the payment status default override file is not present.
-      Rails.logger.warn ":::::: mocks failed to read test_payment_response_status: #{e}"
-      "success"
+      response_status(response_status_filename: "test_payment_response_status", default_status: "success")
     end
 
     # rubocop:disable Metrics/MethodLength

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
       {
@@ -21,48 +21,26 @@ module DefraRubyMocks
 
     # Check if a non-default status value has been requested
     def test_refund_response_status
-      AwsBucketService.read(s3_bucket_name, "test_refund_response_status") || "submitted"
-    rescue StandardError => e
-      # This is expected behaviour when the refund status default override file is not present.
-      Rails.logger.warn ":::::: mocks failed to read test_refund_response_status: #{e}"
-      "submitted"
+      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 ? 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,8 +3,10 @@
 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:)
 
       {
         amount: amount,
@@ -16,23 +18,8 @@ module DefraRubyMocks
 
     private
 
-    # Check if a non-default status value has been requested
     def test_refund_response_status
-      AwsBucketService.read(s3_bucket_name, "test_refund_response_status") || "submitted"
-    rescue StandardError => e
-      # This is expected behaviour when the refund status default override file is not present.
-      Rails.logger.warn ":::::: mocks failed to read test_refund_response_status: #{e}"
-      "submitted"
-    end
-
-    # 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)
+      response_status(response_status_filename: "test_refund_response_status", default_status: "submitted")
     end
 
     def timestamp_file_name

data/lib/defra_ruby_mocks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defra_ruby_mocks
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.1.1
 platform: ruby
 authors:
 - Defra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-06 00:00:00.000000000 Z
+date: 2025-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -91,6 +91,7 @@ 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