defra_ruby_mocks 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c51c15a73b7993b5bbc0d3c15ac48be37739600
-  data.tar.gz: e616e6edd8996fa3ba3c02086ed54dce6af97857
+  metadata.gz: 3fb698051adcf4eb4ef61921f8b493b181a9c731
+  data.tar.gz: 72d8f8e70614b1c8a7c9f95bbf65f7388e468a1b
 SHA512:
-  metadata.gz: 4cf7f91d2ed5fdbff3ce987739a4ae41e77e721a4279c67acd9a79de08b9dc836ec21adfd8d15961000531a509c3668f075f6f97a61833ce8339c11cede98680
-  data.tar.gz: e9a421b752ec91e6bdc2bd30e11a3867994b2a299515080893392d1c74739e8e6549bbc0cc9da39914e25c0daa12f8f7a5df0e7d63b300206545d6cf26e6c84f
+  metadata.gz: dd5da27f28650a3a638c8bdd0a05095797fe65a5043737dba4891cf0bcef7451832c08122ca148c022e04b34f3314baac9e9f6605058961399d792491667ab19
+  data.tar.gz: 9cd9847c9b72135dd27fe2ef81f1132998dbe39291882020f447dd40195fc12804f6a2de9543e5c3ef98493cd4435837dcc88d4cd73c31299eaa7264c4d1b61a

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)
 
@@ -130,6 +130,14 @@ If it does the engine will redirect back to the failure url instead of the succe
 
 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.

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/SuppressedException
 begin
   require "rspec/core/rake_task"
 
@@ -35,4 +34,3 @@ begin
 rescue LoadError
   # no rspec available
 end
-# rubocop:enable Lint/SuppressedException

data/app/controllers/defra_ruby_mocks/worldpay_controller.rb

@@ -15,10 +15,16 @@ module DefraRubyMocks
     end
 
     def dispatcher
-      redirect_to WorldpayResponseService.run(
+      @response = WorldpayResponseService.run(
         success_url: params[:successURL],
         failure_url: params[:failureURL]
       )
+
+      if @response.status == :STUCK
+        render formats: :html, action: "stuck", layout: false
+      else
+        redirect_to @response.url
+      end
     rescue StandardError
       head 500
     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

@@ -5,14 +5,30 @@ module DefraRubyMocks
 
     def run(success_url:, failure_url:)
       parse_reference(success_url)
-      locate_registration
-      @order = last_order
+      @resource = WorldpayResourceService.run(reference: @reference)
 
-      response_url(success_url, failure_url)
+      generate_response(success_url, failure_url)
     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,81 +44,49 @@ 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 reject_payment?
-      @registration.company_name.downcase.include?("reject")
-    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 generate_mac
+    def payment_status
+      return :REFUSED if @resource.company_name.include?("reject")
+      return :STUCK if @resource.company_name.include?("stuck")
+
+      :AUTHORISED
+    end
+
+    def generate_mac(status)
       data = [
         order_key,
         order_value,
         "GBP",
-        "AUTHORISED",
+        status,
         DefraRubyMocks.configuration.worldpay_mac_secret
       ]
 
       Digest::MD5.hexdigest(data.join).to_s
     end
 
-    def query_string(status)
-      [
-        "orderKey=#{order_key}",
-        "paymentStatus=#{status}",
-        "paymentAmount=#{order_value}",
-        "paymentCurrency=GBP",
-        "mac=#{generate_mac}",
-        "source=WP"
-      ].join("&")
-    end
+    def generate_response(success_url, failure_url)
+      status = payment_status
 
-    def response_url(success_url, failure_url)
-      separator = @url_format == :new ? "?" : "&"
-
-      if reject_payment?
-        url = failure_url
-        status = "REFUSED"
-      else
-        url = success_url
-        status = "AUTHORISED"
-      end
-
-      [url, separator, query_string(status)].join
+      WorldpayResponse.new(
+        status == :AUTHORISED ? success_url : failure_url,
+        @url_format == :new ? "?" : "&",
+        order_key,
+        generate_mac(status),
+        order_value,
+        status,
+        @reference
+      )
     end
   end
 end

data/app/views/defra_ruby_mocks/worldpay/stuck.html.erb

@@ -0,0 +1,37 @@
+<!doctype html>
+
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+
+  <title>You is stuck</title>
+  <meta name="description" content="Thw Worldpay stuck page">
+  <meta name="author" content="Defra">
+</head>
+
+<body>
+  <main>
+    <div id="message">
+      <h1>Stuck!</h1>
+      <p>Looks like your registration has gotten stuck whilst paying for it using Worldpay.</p>
+      <p>We hope that's what you expected to happen.</p>
+      <p>Regards, the Ruby Services Team</p>
+    </div>
+    <% if @response %>
+      <div id="debug">
+        <h2>Debug</h2>
+        <ul>
+          <li><strong>Supplied URL</strong> <code><%= @response.supplied_url %></code></li>
+          <li><strong>Separator</strong> <code><%= @response.separator %></code></li>
+          <li><strong>Order key</strong> <code><%= @response.order_key %></code></li>
+          <li><strong>Mac</strong> <code><%= @response.mac %></code></li>
+          <li><strong>Value</strong> <code><%= @response.value %></code></li>
+          <li><strong>Status</strong> <code><%= @response.status %></code></li>
+          <li><strong>Reference</strong> <code><%= @response.reference %></code></li>
+          <li><strong>Url</strong> <code><%= @response.url %></code></li>
+        </ul>
+      </div>
+    <% end %>
+  </main>
+</body>
+</html>

data/lib/defra_ruby_mocks/engine.rb

@@ -2,7 +2,7 @@
 
 require_relative "configuration"
 require_relative "invalid_config_error"
-require_relative "missing_registration_error"
+require_relative "missing_resource_error"
 require_relative "unrecognised_worldpay_request_error"
 
 module DefraRubyMocks

data/lib/defra_ruby_mocks/missing_resource_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DefraRubyMocks
+  class MissingResourceError < StandardError
+    def initialize(reference)
+      super("Could not find resource: #{reference}")
+    end
+  end
+end

data/lib/defra_ruby_mocks/version.rb

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

data/spec/requests/worldpay_spec.rb

@@ -59,30 +59,53 @@ module DefraRubyMocks
       end
 
       context "#dispatcher" do
-        let(:relation) { double(:relation, first: registration) }
-        let(:registration) { double(:registration, finance_details: finance_details, company_name: "What a waste") }
-        let(:finance_details) { double(:finance_details, orders: orders) }
-        let(:orders) { double(:orders, order_by: sorted_orders) }
-        let(:sorted_orders) { double(:sorted_orders, first: order) }
-        let(:order) { double(:order, order_code: "987654", total_amount: 105_00) }
-
+        let(:response_url) { "#{success_url}?orderKey=admincode1^^987654&paymentStatus=#{status}&paymentAmount=10500&paymentCurrency=GBP&mac=0ba5271e1ed1b26f9bb428ef7fb536a4&source=WP" }
         let(:path) { "/defra_ruby_mocks/worldpay/dispatcher?successURL=#{CGI.escape(success_url)}" }
+        let(:service_response) do
+          double(
+            :response,
+            supplied_url: success_url,
+            url: response_url,
+            status: status,
+            separator: "?",
+            order_key: "admincode1",
+            mac: "e5bc7ce5dfe44d2000771ac2b157f0e9",
+            value: 154_00,
+            reference: "12345"
+          )
+        end
 
         context "and the request is valid" do
-          let(:response_params) { "orderKey=admincode1^^987654&paymentStatus=AUTHORISED&paymentAmount=10500&paymentCurrency=GBP&mac=0ba5271e1ed1b26f9bb428ef7fb536a4&source=WP" }
+          before(:each) { allow(WorldpayResponseService).to receive(:run) { service_response } }
+
           let(:success_url) { "http://example.com/fo/12345/worldpay/success" }
 
-          it "redirects the user with a 300 code" do
-            expect(::WasteCarriersEngine::TransientRegistration).to receive(:where) { relation }
+          context "and a response is expected" do
+            let(:status) { "AUTHORISED" }
 
-            get path
+            it "redirects the user with a 300 code" do
+              get path
 
-            expect(response).to redirect_to("#{success_url}?#{response_params}")
-            expect(response.code).to eq("302")
+              expect(response).to redirect_to(response_url)
+              expect(response.code).to eq("302")
+            end
+          end
+
+          context "and a response is not expected" do
+            let(:status) { :STUCK }
+
+            it "renders the Worldpay stuck page" do
+              get path
+
+              expect(response).to render_template(:stuck)
+              expect(response.code).to eq("200")
+            end
           end
         end
 
         context "and the request is invalid" do
+          before(:each) { allow(WorldpayResponseService).to receive(:run).and_raise(MissingResourceError.new("foo")) }
+
           context "because the success url is not in a recognised format" do
             let(:success_url) { "http://example.com/forthewin" }
 

data/spec/services/worldpay_resource_service_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module DefraRubyMocks
+  RSpec.describe WorldpayResourceService do
+    before(:each) do
+      allow(::WasteCarriersEngine::TransientRegistration).to receive(:where) { transient_relation }
+      allow(::WasteCarriersEngine::Registration).to receive(:where) { registration_relation }
+    end
+
+    let(:reference) { "12345" }
+    let(:company_name) { "Pay for the thing" }
+
+    let(:resource) { double(:resource, finance_details: finance_details, company_name: company_name) }
+    let(:finance_details) { double(:finance_details, orders: orders) }
+    let(:orders) { double(:orders, order_by: sorted_orders) }
+    let(:sorted_orders) { double(:sorted_orders, first: order) }
+    let(:order) { double(:order) }
+
+    let(:args) { { reference: reference } }
+
+    describe ".run" do
+
+      context "when the resource is a TransientRegistration" do
+        let(:transient_relation) { double(:relation, first: resource) }
+
+        it "will only search transient registrations" do
+          described_class.run(args)
+
+          expect(::WasteCarriersEngine::TransientRegistration).to have_received(:where).with(token: reference)
+
+          expect(::WasteCarriersEngine::Registration).not_to have_received(:where).with(reg_uuid: reference)
+        end
+
+        it "returns an object with the matching resource" do
+          expect(described_class.run(args).resource).to eq(resource)
+        end
+
+        it "returns an object with the expected order" do
+          expect(described_class.run(args).order).to eq(order)
+        end
+
+        it "returns an object with the expected company name" do
+          expect(described_class.run(args).company_name).to eq(company_name.downcase)
+        end
+      end
+
+      context "when the resource is a Registration" do
+        let(:transient_relation) { double(:relation, first: nil) }
+        let(:registration_relation) { double(:relation, first: resource) }
+
+        it "will search transient registrations first, then registrations" do
+          described_class.run(args)
+
+          expect(::WasteCarriersEngine::TransientRegistration).to have_received(:where).with(token: reference)
+
+          expect(::WasteCarriersEngine::Registration).to have_received(:where).with(reg_uuid: reference)
+        end
+
+        it "returns an object with the matching resource" do
+          expect(described_class.run(args).resource).to eq(resource)
+        end
+
+        it "returns an object with the expected order" do
+          expect(described_class.run(args).order).to eq(order)
+        end
+
+        it "returns an object with the expected company name" do
+          expect(described_class.run(args).company_name).to eq(company_name.downcase)
+        end
+      end
+
+      context "when the resource is a OrderCopyCardsRegistration" do
+        before do
+          # Because we do not copy the company name to
+          # `OrderCopyCardsRegistration` instances when we create them in WCR
+          # we need to locate the orignal registration they are based on. We
+          # determine in the class if the 'resource' is an instance of one by
+          # comparing the result of resource.class.to_s to
+          # "WasteCarriersEngine::OrderCopyCardsRegistration". The problem is
+          # when testing 'resource' is actually an instance of
+          # `RSpec::Mocks::Double`! So we subvert the call to class on
+          # RSpec::Mocks::Double to return "WasteCarriersEngine::OrderCopyCardsRegistration"
+          # just in this spec. We can then test that the service does indeed
+          # locate the original registration for a company name
+          allow_any_instance_of(RSpec::Mocks::Double).to receive(:class)
+            .and_return("WasteCarriersEngine::OrderCopyCardsRegistration")
+        end
+
+        let(:copy_card_resource) { double(:resource, finance_details: finance_details, reg_identifier: "CBDU123") }
+        let(:transient_relation) { double(:relation, first: copy_card_resource) }
+        let(:registration_relation) { double(:relation, first: resource) }
+
+        it "locates the original registration to grab the company name" do
+          expect(described_class.run(args).company_name).to eq(company_name.downcase)
+
+          expect(::WasteCarriersEngine::Registration).to have_received(:where).with(reg_identifier: "CBDU123")
+        end
+      end
+
+      context "when the resource does not exist" do
+        let(:transient_relation) { double(:relation, first: nil) }
+        let(:registration_relation) { double(:relation, first: nil) }
+
+        it "causes an error" do
+          expect { described_class.run(args) }.to raise_error MissingResourceError
+        end
+      end
+    end
+  end
+end

data/spec/services/worldpay_response_service_spec.rb

@@ -3,6 +3,7 @@
 require "rails_helper"
 
 module DefraRubyMocks
+
   RSpec.describe WorldpayResponseService do
     before(:each) do
       Helpers::Configuration.prep_for_tests
@@ -12,10 +13,11 @@ module DefraRubyMocks
         config.worldpay_mac_secret = mac_secret
       end
 
-      allow(::WasteCarriersEngine::TransientRegistration).to receive(:where) { relation }
-      allow(::WasteCarriersEngine::Registration).to receive(:where) { relation }
+      allow(WorldpayResourceService).to receive(:run) { resource }
     end
 
+    let(:resource) { double(:resource, order: order, company_name: company_name.downcase) }
+
     let(:admin_code) { "admincode1" }
     let(:merchant_code) { "merchantcode1" }
     let(:mac_secret) { "mac1" }
@@ -23,12 +25,9 @@ module DefraRubyMocks
     let(:order_code) { "54321" }
     let(:order_key) { "#{admin_code}^#{merchant_code}^#{order_code}" }
     let(:order_value) { 105_00 }
+    let(:payment_status) { :AUTHORISED }
     let(:company_name) { "Pay for the thing" }
 
-    let(:registration) { double(:registration, finance_details: finance_details, company_name: company_name) }
-    let(:finance_details) { double(:finance_details, orders: orders) }
-    let(:orders) { double(:orders, order_by: sorted_orders) }
-    let(:sorted_orders) { double(:sorted_orders, first: order) }
     let(:order) { double(:order, order_code: order_code, total_amount: order_value) }
 
     let(:mac) do
@@ -36,15 +35,13 @@ module DefraRubyMocks
         order_key,
         order_value,
         "GBP",
-        "AUTHORISED",
+        payment_status,
         mac_secret
       ]
 
       Digest::MD5.hexdigest(data.join).to_s
     end
 
-    let(:payment_status) { "AUTHORISED" }
-
     let(:query_string) do
       [
         "orderKey=#{order_key}",
@@ -67,69 +64,47 @@ module DefraRubyMocks
           let(:relation) { double(:relation, first: registration) }
 
           it "can extract the reference from the `success_url`" do
-            described_class.run(args)
-
-            expect(::WasteCarriersEngine::TransientRegistration).to have_received(:where).with(token: reference)
+            expect(described_class.run(args).reference).to eq(reference)
           end
 
           it "can generate a valid order key" do
-            params = parse_for_params(described_class.run(args))
-
-            expect(params["orderKey"]).to eq(order_key)
+            expect(described_class.run(args).order_key).to eq(order_key)
           end
 
           it "can generate a valid mac" do
-            params = parse_for_params(described_class.run(args))
-
-            expect(params["mac"]).to eq(mac)
+            expect(described_class.run(args).mac).to eq(mac)
           end
 
           context "and is for a successful payment" do
             it "returns a url in the expected format" do
-              expected_response = "#{success_url}?#{query_string}"
+              expected_response_url = "#{success_url}?#{query_string}"
 
-              expect(described_class.run(args)).to eq(expected_response)
+              expect(described_class.run(args).url).to eq(expected_response_url)
             end
           end
 
           context "and is for a rejected payment" do
-            let(:payment_status) { "REFUSED" }
+            let(:payment_status) { :REFUSED }
             let(:company_name) { "Reject for the thing" }
 
             it "returns a url in the expected format" do
-              expected_response = "#{failure_url}?#{query_string}"
+              expected_response_url = "#{failure_url}?#{query_string}"
 
-              expect(described_class.run(args)).to eq(expected_response)
+              expect(described_class.run(args).url).to eq(expected_response_url)
             end
           end
-        end
-
-        context "but the registration does not exist" do
-          let(:relation) { double(:relation, first: nil) }
 
-          it "causes an error" do
-            expect { described_class.run(args) }.to raise_error MissingRegistrationError
-          end
-        end
+          context "and is for a stuck payment" do
+            let(:company_name) { "Give me a stuck thing" }
 
-        context "but the registration does not exist" do
-          let(:relation) { double(:relation, first: nil) }
-
-          it "causes an error" do
-            expect { described_class.run(args) }.to raise_error MissingRegistrationError
+            it "returns a status of :STUCK" do
+              expect(described_class.run(args).status).to eq(:STUCK)
+            end
           end
         end
       end
 
       context "when the request comes from the waste-carriers-frontend" do
-        before do
-          # The service will search transient registrations for a match first
-          # before then searching for the registration. Hence we need to stub
-          # `locate_transient_registration()` to allow the service to then
-          # call `locate_registration()`
-          allow_any_instance_of(described_class).to receive(:locate_transient_registration).and_return(nil)
-        end
-
         let(:success_url) { "http://example.com/your-registration/#{reference}/worldpay/success/54321/NEWREG?locale=en" }
         let(:failure_url) { "http://example.com/your-registration/#{reference}/worldpay/failure/54321/NEWREG?locale=en" }
 
@@ -137,48 +112,42 @@ module DefraRubyMocks
           let(:relation) { double(:relation, first: registration) }
 
           it "can extract the reference from the `success_url`" do
-            described_class.run(args)
-
-            expect(::WasteCarriersEngine::Registration).to have_received(:where).with(reg_uuid: reference)
+            expect(described_class.run(args).reference).to eq(reference)
           end
 
           it "can generate a valid order key" do
-            params = parse_for_params(described_class.run(args))
-
-            expect(params["orderKey"]).to eq(order_key)
+            expect(described_class.run(args).order_key).to eq(order_key)
           end
 
           it "can generate a valid mac" do
-            params = parse_for_params(described_class.run(args))
-
-            expect(params["mac"]).to eq(mac)
+            expect(described_class.run(args).mac).to eq(mac)
           end
 
           context "and is for a successful payment" do
             it "returns a url in the expected format" do
-              expected_response = "#{success_url}&#{query_string}"
+              expected_response_url = "#{success_url}&#{query_string}"
 
-              expect(described_class.run(args)).to eq(expected_response)
+              expect(described_class.run(args).url).to eq(expected_response_url)
             end
           end
 
           context "and is for a rejected payment" do
-            let(:payment_status) { "REFUSED" }
+            let(:payment_status) { :REFUSED }
             let(:company_name) { "Reject for the thing" }
 
             it "returns a url in the expected format" do
-              expected_response = "#{failure_url}&#{query_string}"
+              expected_response_url = "#{failure_url}&#{query_string}"
 
-              expect(described_class.run(args)).to eq(expected_response)
+              expect(described_class.run(args).url).to eq(expected_response_url)
             end
           end
-        end
 
-        context "but the registration does not exist" do
-          let(:relation) { double(:relation, first: nil) }
+          context "and is for a stuck payment" do
+            let(:company_name) { "Give me a stuck thing" }
 
-          it "causes an error" do
-            expect { described_class.run(args) }.to raise_error MissingRegistrationError
+            it "returns a status of :STUCK" do
+              expect(described_class.run(args).status).to eq(:STUCK)
+            end
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defra_ruby_mocks
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Defra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-31 00:00:00.000000000 Z
+date: 2020-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.2.11.1
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.2
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -127,17 +141,19 @@ files:
 - app/services/defra_ruby_mocks/worldpay_payment_service.rb
 - app/services/defra_ruby_mocks/worldpay_refund_service.rb
 - app/services/defra_ruby_mocks/worldpay_request_handler_service.rb
+- app/services/defra_ruby_mocks/worldpay_resource_service.rb
 - app/services/defra_ruby_mocks/worldpay_response_service.rb
 - app/views/defra_ruby_mocks/company/not_found.json.erb
 - app/views/defra_ruby_mocks/company/show.json.erb
 - app/views/defra_ruby_mocks/worldpay/payment_request.xml.erb
 - app/views/defra_ruby_mocks/worldpay/refund_request.xml.erb
+- app/views/defra_ruby_mocks/worldpay/stuck.html.erb
 - config/routes.rb
 - lib/defra_ruby_mocks.rb
 - lib/defra_ruby_mocks/configuration.rb
 - lib/defra_ruby_mocks/engine.rb
 - lib/defra_ruby_mocks/invalid_config_error.rb
-- lib/defra_ruby_mocks/missing_registration_error.rb
+- lib/defra_ruby_mocks/missing_resource_error.rb
 - lib/defra_ruby_mocks/unrecognised_worldpay_request_error.rb
 - lib/defra_ruby_mocks/version.rb
 - lib/tasks/changelog.rake
@@ -173,7 +189,6 @@ files:
 - spec/dummy/config/locales/en.yml
 - spec/dummy/config/routes.rb
 - spec/dummy/config/secrets.yml
-- spec/dummy/log/test.log
 - spec/dummy/public/404.html
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
@@ -191,6 +206,7 @@ files:
 - spec/services/worldpay_payment_service_spec.rb
 - spec/services/worldpay_refund_service_spec.rb
 - spec/services/worldpay_request_handler_service_spec.rb
+- spec/services/worldpay_resource_service_spec.rb
 - spec/services/worldpay_response_service_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers/configuration.rb
@@ -258,7 +274,6 @@ test_files:
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
 - spec/dummy/public/404.html
-- spec/dummy/log/test.log
 - spec/dummy/README.rdoc
 - spec/defra_ruby_mocks_spec.rb
 - spec/requests/company_spec.rb
@@ -277,6 +292,7 @@ test_files:
 - spec/fixtures/refund_request_invalid.xml
 - spec/rails_helper.rb
 - spec/services/worldpay_response_service_spec.rb
+- spec/services/worldpay_resource_service_spec.rb
 - spec/services/companies_house_service_spec.rb
 - spec/services/worldpay_payment_service_spec.rb
 - spec/services/worldpay_refund_service_spec.rb

data/lib/defra_ruby_mocks/missing_registration_error.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module DefraRubyMocks
-  class MissingRegistrationError < StandardError
-    def initialize(reference)
-      super("Could not find registration: #{reference}")
-    end
-  end
-end