defra_ruby_mocks 2.3.3 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9215253284f8928c0b731ac83de618da7e328ee04a75453290956132bb72d65d
-  data.tar.gz: 56087ad7a0263a7d6cb70d2a6d02df385c33262735a544921fbd0f25a7a607f8
+  metadata.gz: ecd1c75dcaf3f1a8f981977e335d936065a72c1df1cd6ffd6b3b019c2a366e9e
+  data.tar.gz: 5e3b19f300e4397f597069df784489a650d3ed87736778c1aee2dcd2438fc836
 SHA512:
-  metadata.gz: c2fa8dee0d93abf131a79cad79b6a94c58fa6e9541051c9d39fbba645b294b35ce7246a4ebc69a4854765ac002b6e77acb98fa6cad785b0a82bb4ad4b0c4f7f4
-  data.tar.gz: c01f83850554a60d11341677892d92e9c13613481aa48d5967ed3fdbdd6de5f45620ceb7623294d58656e23b3a4e4decfc9ffa1431ae656757db5bc559c9197e
+  metadata.gz: 3d70df2364b1bd260dd72ad8e2d36791335d6b671c03e87d1da9665dc0416984dbb2d30290a95666f85d76610e6331e717bb9060bdc112c80f921c2d0da1ba6f
+  data.tar.gz: b1a0697b585fd1be014cb8300569a3b9323e56de1398422e710a35c9cc4598b9d4072b44008386c244c4eef735491d7dbd2b1895c9bab44c91e3a033a56e33d4

data/README.md

@@ -132,117 +132,74 @@ The list of possible statuses was taken from
 - [Companies House API](https://developer.companieshouse.gov.uk/api/docs/company/company_number/companyProfile-resource.html)
 - [Companies House API enumerations](https://github.com/companieshouse/api-enumerations/blob/master/constants.yml)
 
-### Worldpay
+### Govpay
 
-When mounted into an app you can simulate interacting with the Worldpay hosted pages service.
+When mounted into an app you can simulate interacting with the Govpay hosted pages service. The following endpoints are supported:
 
-#### Payments
-
-Making a payment with Worldpay essentially comes in 2 stages
-
-1. The app sends an XML request to Worldpay asking it to prepare for a new payment. Worldpay responds with a reference and a URL to redirect the user to
-2. The app redirects the user to the URL and adds to it query params that tell Worldpay where to redirect the user to when the payment is complete
-
-For more details check out [Making a payment with WorldPay](https://github.com/DEFRA/ruby-services-team/blob/master/services/wcr/payment_with_worldpay.md)
-
-This Worldpay mock replicates those 2 interactions with the following urls
-
-- `../worldpay/payments-service`
-- `../worldpay/dispatcher`
-
-##### Cancelled payments
-
-The engine has the ability to mock a user cancelling a payment when on the Worldpay site. To have the mock return a cancelled payment response just ensure the registration's company name includes the word `cancel` (case doesn't matter).
-
-If it does the engine will redirect back to the cancelled url instead of the success url provided, plus set the payment status to `CANCELLED`.
-
-This allows us to test how the application handles Worldpay responding with a cancelled payment response.
-
-##### Errored payments
-
-The engine has the ability to Worldpay erroring during a payment. To have the mock return an errored payment response just ensure the registration's company name includes the word `error` (case doesn't matter).
-
-If it does the engine will redirect back to the error url instead of the success url provided, plus set the payment status to `ERROR`.
-
-This allows us to test how the application handles Worldpay responding with an errored payment response.
-
-##### Pending payments
-
-The engine has the ability to also mock Worldpay marking a payment as pending. To have the mock return a payment pending response just ensure the registration's company name includes the word `pending` (case doesn't matter).
+- `POST /govpay/v1/payments`
+  - Create a payment. In its current form it always returns a fixed (success) response regardless of the input parameters.
+- `GET /govpay/v1/payments/:payment_id`
+  - Get details of an existing payment. The response includes the payment_id from the input parameters, a random amount, and the current time as created_at value.
+- `POST /govpay/v1/payments/:payment_id/refunds`
+  - Request a refund. The response includes the amount from the input parameters and a status of "submitted", meaning that the refund is pending. It also writes the current time to a temporary file to support refund details checking - see *Govpay refund status* below.
+- `GET /govpay/v1/payments/:payment_id/refunds/:refund_id`
+  - Get the details of an existing refund. This currently returns a fixed response, with the exception of the `status` value. See *Govpay refund status* below.
 
-If it does the engine will redirect back to the pending url instead of the success url provided, plus set the payment status to `SENT_FOR_AUTHORISATION`.
+#### Govpay refund status
+The Govpay service behaves differently in production and in test (sandbox) modes.
+- In **production**, a refund is initially assigned a status of `submitted` and this is the `status` value that will be received in the response to a successful create refund request. When the payment provider processes the refund, the status within the Govpayservice will be updated to `success`. 
+- In **sandbox** mode, a refund will be assigned a status of `success` as soon as it is created.
 
-This allows us to test how the application handles Worldpay responding with a payment pending response.
+This causes issues for testing, as it is not possible to test behaviour around `submitted` (i.e. pending) refunds. To mitigate this, the mock API for getting refund details behaves as follows:
+- Default: Return success
+- If the environment variable `GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG` is set (integer value):
+  - If fewer than that number of seconds has elapsed since the most recent refund request, return submitted
+  - If greater than that number of seconds has elapsed since the most recent refund request, return success
 
-##### Refused payments
+So setting the `GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG` variable should allow a developer or tester to simulate production behaviour. The iniital response will be `submitted`; checking the refund status before the specified lag has passed will also return `submitted`; and checking the refund status after the lag has passed will return `success`.
 
-The engine has the ability to also mock Worldpay refusing a payment. To have the mock refuse payment just ensure the registration's company name includes the word `reject` (case doesn't matter).
-
-If it does the engine will redirect back to the failure url instead of the success url provided, plus set the payment status to `REFUSED`.
-
-This allows us to test how the application handles both successful and unsucessful Worldpay payments.
-
-##### Stuck payments
-
-The engine has the ability to also mock Worldpay not redirecting back to the service. This is the equivalent of a registration getting 'stuck at Worldpay'. To have the mock not respond just ensure the registration's company name includes the word `stuck` (case doesn't matter).
-
-If it does the engine will not redirect back to the service, but instead render a 'You're stuck!' page.
-
-This allows us to test how the application handles Worldpay not returning after we redirect a user to them.
-
-#### Refunds
+#### Payments
 
-Requesting a refund from Worldpay is a single step process.
+Making a payment with Govpay requires three steps:
 
-1. The app sends an XML request to Worldpay with details of the order to be refunded and the amount. Worldpay returns an XML response confirming the request has been received
+1. The app sends a JSON request to Govpay asking it to prepare for a new payment, and providing a unique identifier and a callback URL.
+2. Govpay subsequently invokes the callback URL, passing a Govpay URL to which the user should be redirected.
+2. The app redirects the user to the Govpay URL with params that tell Govpay where to redirect the user to when the payment is complete.
 
-Like payments, refund requests are also sent to the same url `../worldpay/payments-service`. The mock handles determining what request is being made and returns the appropriate response.
+This Govpay mock replicates those 2 interactions with the following url
+- `../govpay/v1/payments`
 
 #### Configuration
 
-In order to use the Worldpay mock you'll need to provide additional configuration details
+In order to use the govpay mock you'll need to provide additional configuration details
 
 ```ruby
 # config/initializers/defra_ruby_mocks.rb
 require "defra_ruby_mocks"
 
 DefraRubyMocks.configure do |config|
-  config.enable = true
-  config.delay = 1000
-
-  config.worldpay_admin_code = "admincode1"
-  config.worldpay_mac_secret = "macsecret1"
-  config.worldpay_merchant_code = "merchantcode1"
-  config.worldpay_domain = "http://localhost:3000/mocks"
+  config.govpay_domain = File.join(ENV["WCRS_GOVPAY_DOMAIN"] || "http://localhost:3002", "/fo/mocks/govpay/v1")
 end
 ```
 
-It's important that the admin code, mac secret and merchant code are the same as used by the apps calling the Worldpay mock. These values are used when generating the responses and are validated by the apps so it's important they match.
-
-The domain is used when generating the URL we tell the app to redirect users to. As this is just an engine and not a standalone service, we need to tell it what domain it is running from. For example, if the engine is mounted into the app like this
+The domain is used when generating the URL we tell the app to redirect users to. As this is just an engine and not a standalone service, we need to tell it what domain it is running from.
 
 ```ruby
 mount DefraRubyMocks::Engine => "/mocks"
 ```
 
-And the app is running at `http://localhost:3000`, this engine can then use that information to tell the app to redirect users to `http://localhost:3000/mocks/worldpay/dispatcher` as part of the `payments-service` response.
-
 #### Only for Waste Carriers
 
-At this time there is only one digital service built using Ruby on Rails that uses Worldpay; the [Waste Carriers Registration service](https://github.com/DEFRA/ruby-services-team/tree/master/services/wcr). So the Worldpay mock has been written with the assumption it will only be mounted into one of the Waste Carriers apps.
+At this time there is only one digital service built using Ruby on Rails that uses Govpay; the [Waste Carriers Registration service](https://github.com/DEFRA/ruby-services-team/tree/master/services/wcr). So the Govpay mock has been written with the assumption it will only be mounted into one of the Waste Carriers apps.
 
 A critical aspect of this is the expectation that the following classes will be loaded and available when the engine is mounted and the app is running
 
 - `WasteCarriersEngine::TransientRegistration`
 - `WasteCarriersEngine::Registration`
 
-We need these classes so we can use them to query the database for the registration the payment is being made against. We only get the registration reference in the request made to `/worldpay/dispatcher`, not the order code. As the response needs to include the order code we need access to these ActiveRecord models to locate the last order added.
-
-In the live Worldpay service this information (along with the amount to be paid) is saved after the initial request to `/payments-service`. The mock however isn't persisting anything to reduce complexity. So instead it needs to be able to query the database for the information it needs via ActiveRecord.
-
 #### Payment pages are not mocked
 
-The actual Worldpay service presents payment pages that display a form where users are able to enter their credit card details and confirm the payment is correct. This mock does **not** replicate the UI of Worldpay, only the API. Bear this in mind when building any automated acceptance tests.
+The actual Govpay service presents payment pages that display a form where users are able to enter their credit card details and confirm the payment is correct. This mock does **not** replicate the UI of Govpay, only the API. Bear this in mind when building any automated acceptance tests.
 
 ## Installation
 

data/app/controllers/defra_ruby_mocks/govpay_controller.rb

@@ -27,6 +27,23 @@ module DefraRubyMocks
       head 422
     end
 
+    def create_refund
+      valid_create_refund_params
+      render json: GovpayRequestRefundService.new.run(payment_id: params[:payment_id],
+                                                      amount: params[:amount],
+                                                      refund_amount_available: params[:refund_amount_available])
+    rescue StandardError => e
+      Rails.logger.error("MOCKS: Govpay refund error: #{e.message}")
+      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}")
+      head 500
+    end
+
     def valid_create_params
       params.require(%i[amount description return_url])
     end
@@ -36,5 +53,11 @@ module DefraRubyMocks
 
       raise ArgumentError, "Invalid Govpay payment ID #{params[:payment_id]}"
     end
+
+    def valid_create_refund_params
+      valid_payment_id
+      raise ArgumentError, "Invalid refund amount" unless params[:amount].present?
+      raise ArgumentError, "Invalid refund amount available" unless params[:refund_amount_available].present?
+    end
   end
 end

data/app/services/defra_ruby_mocks/govpay_refund_details_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class GovpayRefundDetailsService < BaseService
+
+    def run(payment_id:, refund_id:) # rubocop:disable Lint/UnusedMethodArgument
+      {
+        "amount": 2000,
+        "created_date": "2019-09-19T16:53:03.213Z",
+        "refund_id": "j6se0f2o427g28g8yg3u3i",
+        "status": status,
+        "settlement_summary": {
+          "settled_date": "2019-09-21"
+        }
+      }
+    end
+
+    private
+
+    # "submitted" for up to GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG seconds after the last refund request, then "success"
+    def status
+      timestamp = File.read("#{Dir.tmpdir}/govpay_request_refund_service_last_run_time")
+      last_refund_time = timestamp ? Time.parse(timestamp) : 1.day.ago
+      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"
+    rescue Errno::ENOENT
+      write_timestamp_file("govpay_request_refund_service_last_run_time")
+
+      "success"
+    end
+
+    def write_timestamp_file(filename)
+      filepath = "#{Dir.tmpdir}/#{filename}"
+
+      # FileUtils.touch seems unreliable in VM so need to write/read the actual time
+      File.write(filepath, Time.zone.now)
+    end
+
+  end
+end

data/app/services/defra_ruby_mocks/govpay_request_refund_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class GovpayRequestRefundService < BaseService
+
+    def run(payment_id:, amount:, refund_amount_available:) # rubocop:disable Lint/UnusedMethodArgument
+      write_timestamp
+
+      # This currently supports only "submitted" status:
+      {
+        "amount": amount,
+        "created_date": "2019-09-19T16:53:03.213Z",
+        "refund_id": "j6se0f2o427g28g8yg3u3i",
+        "status": "submitted"
+      }
+    end
+
+    private
+
+    # let the refund details service know how long since the refund was requested
+    def write_timestamp
+      filepath = "#{Dir.tmpdir}/govpay_request_refund_service_last_run_time"
+      # FileUtils.touch seems unreliable in VM so need to write/read the actual time
+      File.write(filepath, Time.zone.now)
+    end
+  end
+end

data/config/routes.rb

@@ -11,16 +11,6 @@ DefraRubyMocks::Engine.routes.draw do
       as: "company_officers",
       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
 
-  post "/worldpay/payments-service",
-       to: "worldpay#payments_service",
-       as: "worldpay_payments_service",
-       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
-
-  get "/worldpay/dispatcher",
-      to: "worldpay#dispatcher",
-      as: "worldpay_dispatcher",
-      constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
-
   post "/govpay/v1/payments",
        to: "govpay#create_payment",
        as: "govpay_create_payment",
@@ -30,4 +20,14 @@ DefraRubyMocks::Engine.routes.draw do
       to: "govpay#payment_details",
       as: "govpay_payment_details",
       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
+
+  post "/govpay/v1/payments/:payment_id/refunds",
+       to: "govpay#create_refund",
+       as: "govpay_create_refund",
+       constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
+
+  get "/govpay/v1/payments/:payment_id/refunds/:refund_id",
+      to: "govpay#refund_details",
+      as: "govpay_refund_details",
+      constraints: ->(_request) { DefraRubyMocks.configuration.enabled? }
 end

data/lib/defra_ruby_mocks/configuration.rb

@@ -5,7 +5,7 @@ module DefraRubyMocks
 
     DEFAULT_DELAY = 1000
 
-    attr_accessor :worldpay_admin_code, :worldpay_mac_secret, :worldpay_merchant_code, :worldpay_domain, :govpay_domain
+    attr_accessor :govpay_domain
     attr_reader :delay
 
     def initialize

data/lib/defra_ruby_mocks/engine.rb

@@ -3,7 +3,6 @@
 require_relative "configuration"
 require_relative "invalid_config_error"
 require_relative "missing_resource_error"
-require_relative "unrecognised_worldpay_request_error"
 
 module DefraRubyMocks
   class Engine < ::Rails::Engine

data/lib/defra_ruby_mocks/version.rb

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