defra_ruby_mocks 1.1.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8fcd5775c21149e97c7c65f92b1f469adf065565
-  data.tar.gz: b056b6419ada5eb1bf86dcabaee805cf6eae155a
+SHA256:
+  metadata.gz: 49581eea82699de82215ca95ff2dab0ff58b782e9c322003859bf211669ae717
+  data.tar.gz: 9ee91cdb992f56c2fee2a71be9c4c19d2289b19ea03c29e61076e23f064b19a6
 SHA512:
-  metadata.gz: b6239c9c0d4ea46e2cb47b89dc44c67df263fcddf2704f85b46536529f6db67427f3f830d4842c0943f2eb9eb61558e92d08ac0d2bfd0bd81ec3b010f66f5de7
-  data.tar.gz: 494e1b4a8ef9bf6645be512e915faf5c41dfbc0927da4eb2dcda28f52bef8389adc7bd944437c01aca8ba8e40f10565fd6a0f02ad5a5377e773a22b7011cc141
+  metadata.gz: ceeb708b2dd35c00eca628e935edc3e6db111cb731a6cb2721885f00dc7618d1778ff0ad4487b1f9b131e1db9c193ed222b74a148623dcfc84e1de2e55fc842b
+  data.tar.gz: 2db7ba1c4d5c1c484b414949e04622809fcd906767c8af69990d19709e6e210f968fbc6657af3f2adfa561e938398e79211b95c4a3cca95224c380ed377b7660

data/README.md

@@ -1,8 +1,8 @@
 # Defra Ruby Mocks
 
 [![Build Status](https://travis-ci.com/DEFRA/defra-ruby-mocks.svg?branch=master)](https://travis-ci.com/DEFRA/defra-ruby-mocks)
-[![Maintainability](https://api.codeclimate.com/v1/badges/8b14cc1e0e1c1d6a33cc/maintainability)](https://codeclimate.com/github/DEFRA/defra-ruby-mocks/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/8b14cc1e0e1c1d6a33cc/test_coverage)](https://codeclimate.com/github/DEFRA/defra-ruby-mocks/test_coverage)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=DEFRA_defra-ruby-mocks&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=DEFRA_defra-ruby-mocks)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=DEFRA_defra-ruby-mocks&metric=coverage)](https://sonarcloud.io/dashboard?id=DEFRA_defra-ruby-mocks)
 [![security](https://hakiri.io/github/DEFRA/defra-ruby-mocks/master.svg)](https://hakiri.io/github/DEFRA/defra-ruby-mocks/master)
 [![Licence](https://img.shields.io/badge/Licence-OGLv3-blue.svg)](http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3)
 
@@ -108,6 +108,8 @@ The list of possible statuses was taken from
 
 When mounted into an app you can simulate interacting with the Worldpay hosted pages service.
 
+#### 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
@@ -120,6 +122,54 @@ 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).
+
+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`.
+
+This allows us to test how the application handles Worldpay responding with a payment pending response.
+
+##### Refused payments
+
+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
+
+Requesting a refund from Worldpay is a single step process.
+
+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
+
+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.
+
 #### Configuration
 
 In order to use the Worldpay mock you'll need to provide additional configuration details

data/Rakefile

@@ -25,7 +25,6 @@ Bundler::GemHelper.install_tasks
 # This is wrapped to prevent an error when rake is called in environments where
 # rspec may not be available, e.g. production. As such we don't need to handle
 # the error.
-# rubocop:disable Lint/HandleExceptions
 begin
   require "rspec/core/rake_task"
 
@@ -35,4 +34,3 @@ begin
 rescue LoadError
   # no rspec available
 end
-# rubocop:enable Lint/HandleExceptions

data/app/controllers/defra_ruby_mocks/company_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module DefraRubyMocks
-  class CompanyController < ApplicationController
+  class CompanyController < ::DefraRubyMocks::ApplicationController
 
     before_action :set_default_response_format
 

data/app/controllers/defra_ruby_mocks/worldpay_controller.rb

@@ -1,27 +1,36 @@
 # frozen_string_literal: true
 
 module DefraRubyMocks
-  class WorldpayController < ApplicationController
+  class WorldpayController < ::DefraRubyMocks::ApplicationController
 
     before_action :set_default_response_format
 
     def payments_service
-      response_values = WorldpayRequestService.run(request.body.read)
+      @values = WorldpayRequestHandlerService.run(convert_request_body_to_xml)
 
-      @merchant_code = response_values[:merchant_code]
-      @order_code = response_values[:order_code]
-      @worldpay_id = response_values[:id]
-      @worldpay_url = response_values[:url]
-
-      respond_to :xml
-    rescue StandardError
+      render_payment_response if @values[:request_type] == :payment
+      render_refund_response if @values[:request_type] == :refund
+    rescue StandardError => e
+      Rails.logger.error("MOCKS: Worldpay payments service error: #{e.message}")
       head 500
     end
 
     def dispatcher
-      success_url = params[:successURL]
-      redirect_to WorldpayResponseService.run(success_url)
-    rescue StandardError
+      @response = WorldpayResponseService.run(
+        success_url: params[:successURL],
+        failure_url: params[:failureURL],
+        pending_url: params[:pendingURL],
+        cancel_url: params[:cancelURL],
+        error_url: params[:errorURL]
+      )
+
+      if @response.status == :STUCK
+        render formats: :html, action: "stuck", layout: false
+      else
+        redirect_to @response.url
+      end
+    rescue StandardError => e
+      Rails.logger.error("MOCKS: Worldpay dispatcher error: #{e.message}")
       head 500
     end
 
@@ -31,5 +40,17 @@ module DefraRubyMocks
       request.format = :xml
     end
 
+    def convert_request_body_to_xml
+      Nokogiri::XML(request.body.read)
+    end
+
+    def render_payment_response
+      render "defra_ruby_mocks/worldpay/payment_request"
+    end
+
+    def render_refund_response
+      render "defra_ruby_mocks/worldpay/refund_request"
+    end
+
   end
 end

data/app/services/defra_ruby_mocks/{worldpay_request_service.rb → worldpay_payment_service.rb}

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 module DefraRubyMocks
-  class WorldpayRequestService < BaseService
-    def run(data)
+  class WorldpayPaymentService < BaseService
+    def run(merchant_code:, xml:)
       check_config
 
-      xml = Nokogiri::XML(data)
-      @merchant_code = extract_merchant_code(xml)
+      @merchant_code = merchant_code
       @order_code = extract_order_code(xml)
 
       {
@@ -25,11 +24,6 @@ module DefraRubyMocks
       raise InvalidConfigError, :worldpay_domain if domain.blank?
     end
 
-    def extract_merchant_code(xml)
-      payment_service = xml.at_xpath("//paymentService")
-      payment_service.attribute("merchantCode").text
-    end
-
     def extract_order_code(xml)
       order = xml.at_xpath("//order")
       order.attribute("orderCode").text

data/app/services/defra_ruby_mocks/worldpay_refund_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class WorldpayRefundService < BaseService
+    def run(merchant_code:, xml:)
+      {
+        merchant_code: merchant_code,
+        order_code: extract_order_code(xml),
+        refund_value: extract_refund_value(xml),
+        currency_code: extract_currency_code(xml),
+        exponent: extract_exponent(xml)
+      }
+    end
+
+    private
+
+    def extract_order_code(xml)
+      order_modification = xml.at_xpath("//orderModification")
+      order_modification.attribute("orderCode").text
+    end
+
+    def extract_refund_value(xml)
+      amount = xml.at_xpath("//amount")
+      amount.attribute("value").text
+    end
+
+    def extract_currency_code(xml)
+      amount = xml.at_xpath("//amount")
+      amount.attribute("currencyCode").text
+    end
+
+    def extract_exponent(xml)
+      amount = xml.at_xpath("//amount")
+      amount.attribute("exponent").text
+    end
+  end
+end

data/app/services/defra_ruby_mocks/worldpay_request_handler_service.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class WorldpayRequestHandlerService < BaseService
+    def run(xml)
+      arguments = {
+        merchant_code: extract_merchant_code(xml),
+        xml: xml
+      }
+
+      generate_response(arguments)
+    end
+
+    private
+
+    def extract_merchant_code(xml)
+      payment_service = xml.at_xpath("//paymentService")
+      payment_service.attribute("merchantCode").text
+    end
+
+    def generate_response(arguments)
+      return WorldpayPaymentService.run(arguments).merge(request_type: :payment) if payment_request?(arguments[:xml])
+      return WorldpayRefundService.run(arguments).merge(request_type: :refund) if refund_request?(arguments[:xml])
+
+      raise UnrecognisedWorldpayRequestError
+    end
+
+    def payment_request?(xml)
+      submit = xml.at_xpath("//submit")
+
+      !submit.nil?
+    end
+
+    def refund_request?(xml)
+      modify = xml.at_xpath("//modify")
+
+      !modify.nil?
+    end
+  end
+end

data/app/services/defra_ruby_mocks/worldpay_resource_service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class WorldpayResourceService < BaseService
+
+    def run(reference:)
+      @reference = reference
+
+      raise(MissingResourceError, @reference) if resource.nil?
+
+      WorldpayResource.new(resource, order, company_name)
+    end
+
+    private
+
+    WorldpayResource = Struct.new(:resource, :order, :company_name)
+
+    def resource
+      @_resource ||= locate_transient_registration || locate_completed_registration
+    end
+
+    def locate_transient_registration
+      "WasteCarriersEngine::TransientRegistration"
+        .constantize
+        .where(token: @reference)
+        .first
+    end
+
+    def locate_completed_registration
+      "WasteCarriersEngine::Registration"
+        .constantize
+        .where(reg_uuid: @reference)
+        .first
+    end
+
+    def locate_original_registration(reg_identifier)
+      "WasteCarriersEngine::Registration"
+        .constantize
+        .where(reg_identifier: reg_identifier)
+        .first
+    end
+
+    def order
+      @_order ||= resource.finance_details&.orders&.order_by(dateCreated: :desc)&.first
+    end
+
+    def company_name
+      if resource.class.to_s == "WasteCarriersEngine::OrderCopyCardsRegistration"
+        locate_original_registration(resource.reg_identifier).company_name.downcase
+      else
+        resource.company_name.downcase
+      end
+    end
+  end
+end

data/app/services/defra_ruby_mocks/worldpay_response_service.rb

@@ -3,16 +3,40 @@
 module DefraRubyMocks
   class WorldpayResponseService < BaseService
 
-    def run(success_url)
-      parse_reference(success_url)
-      locate_registration
-      @order = last_order
-
-      response_url(success_url)
+    def run(success_url:, failure_url:, pending_url:, cancel_url:, error_url:)
+      urls = {
+        success: success_url,
+        failure: failure_url,
+        pending: pending_url,
+        cancel: cancel_url,
+        error: error_url
+      }
+
+      parse_reference(urls[:success])
+      @resource = WorldpayResourceService.run(reference: @reference)
+
+      generate_response(urls)
     end
 
     private
 
+    WorldpayResponse = Struct.new(:supplied_url, :separator, :order_key, :mac, :value, :status, :reference) do
+      def url
+        [supplied_url, separator, params].join
+      end
+
+      def params
+        [
+          "orderKey=#{order_key}",
+          "paymentStatus=#{status}",
+          "paymentAmount=#{value}",
+          "paymentCurrency=GBP",
+          "mac=#{mac}",
+          "source=WP"
+        ].join("&")
+      end
+    end
+
     def parse_reference(url)
       path = URI.parse(url).path
       parts = path.split("/")
@@ -28,71 +52,66 @@ module DefraRubyMocks
       end
     end
 
-    def locate_registration
-      @registration = locate_transient_registration || locate_completed_registration
-
-      raise(MissingRegistrationError, @reference) if @registration.nil?
-    end
-
-    def locate_transient_registration
-      "WasteCarriersEngine::TransientRegistration"
-        .constantize
-        .where(token: @reference)
-        .first
-    end
-
-    def locate_completed_registration
-      "WasteCarriersEngine::Registration"
-        .constantize
-        .where(reg_uuid: @reference)
-        .first
-    end
-
-    def last_order
-      @registration.finance_details&.orders&.order_by(dateCreated: :desc)&.first
-    end
-
     def order_key
       [
         DefraRubyMocks.configuration.worldpay_admin_code,
         DefraRubyMocks.configuration.worldpay_merchant_code,
-        @order.order_code
+        @resource.order.order_code
       ].join("^")
     end
 
     def order_value
-      @order.total_amount.to_s
+      @resource.order.total_amount.to_s
+    end
+
+    def payment_status
+      return :REFUSED if @resource.company_name.include?("reject")
+      return :STUCK if @resource.company_name.include?("stuck")
+      return :SENT_FOR_AUTHORISATION if @resource.company_name.include?("pending")
+      return :CANCELLED if @resource.company_name.include?("cancel")
+      return :ERROR if @resource.company_name.include?("error")
+
+      :AUTHORISED
+    end
+
+    def url(payment_status, urls)
+      return urls[:failure] if %i[REFUSED STUCK].include?(payment_status)
+      return urls[:pending] if payment_status == :SENT_FOR_AUTHORISATION
+      return urls[:cancel] if payment_status == :CANCELLED
+      return urls[:error] if payment_status == :ERROR
+
+      urls[:success]
     end
 
-    def generate_mac
+    # Generate a mac that matches what Worldpay would generate
+    #
+    # For whatever reason, if the payment is cancelled by the user Worldpay does
+    # not include the payment status in the mac it generates. Plus the order of
+    # things in the array is important.
+    def generate_mac(status)
       data = [
         order_key,
         order_value,
-        "GBP",
-        "AUTHORISED",
-        DefraRubyMocks.configuration.worldpay_mac_secret
+        "GBP"
       ]
+      data << status unless status == :CANCELLED
+      data << DefraRubyMocks.configuration.worldpay_mac_secret
 
       Digest::MD5.hexdigest(data.join).to_s
     end
 
-    def query_string
-      [
-        "orderKey=#{order_key}",
-        "paymentStatus=AUTHORISED",
-        "paymentAmount=#{order_value}",
-        "paymentCurrency=GBP",
-        "mac=#{generate_mac}",
-        "source=WP"
-      ].join("&")
-    end
+    def generate_response(urls)
+      status = payment_status
 
-    def response_url(success_url)
-      if @url_format == :new
-        "#{success_url}?#{query_string}"
-      else
-        "#{success_url}&#{query_string}"
-      end
+      WorldpayResponse.new(
+        url(status, urls),
+        @url_format == :new ? "?" : "&",
+        order_key,
+        generate_mac(status),
+        order_value,
+        status,
+        @reference
+      )
     end
   end
 end