defra_ruby_mocks 1.1.0 → 1.5.0

data/spec/services/worldpay_request_handler_service_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+module DefraRubyMocks
+  RSpec.describe WorldpayRequestHandlerService do
+    describe ".run" do
+      context "when a request is made" do
+
+        let(:merchant_code) { "MERCHME" }
+        let(:args) { { merchant_code: merchant_code, xml: xml } }
+
+        context "and it's for a payment" do
+          before do
+            allow_any_instance_of(WorldpayPaymentService).to receive(:generate_id) { order_id }
+          end
+
+          let(:xml) { Nokogiri::XML(File.read("spec/fixtures/payment_request_valid.xml")) }
+          let(:order_id) { "1234567890" }
+          let(:request_type) { { request_type: :payment } }
+          let(:response_values) do
+            {
+              merchant_code: merchant_code,
+              order_code: "1577726052",
+              id: order_id,
+              url: "http://example.com"
+            }
+          end
+
+          it "correctly determines the request service to use" do
+            expect(WorldpayPaymentService).to receive(:run).with(args) { response_values }
+
+            described_class.run(xml)
+          end
+
+          it "returns the values the controller needs to handle the request" do
+            expect(WorldpayPaymentService).to receive(:run).with(args) { response_values }
+
+            expect(described_class.run(xml)).to eq(request_type.merge(response_values))
+          end
+        end
+
+        context "and it's for a refund" do
+          let(:xml) { Nokogiri::XML(File.read("spec/fixtures/refund_request_valid.xml")) }
+          let(:request_type) { { request_type: :refund } }
+          let(:response_values) do
+            {
+              merchant_code: merchant_code,
+              order_code: "1579644835",
+              refund_value: "2500",
+              currency_code: "GBP",
+              exponent: "2"
+            }
+          end
+
+          it "correctly determines the request service to use" do
+            expect(WorldpayRefundService).to receive(:run).with(args) { response_values }
+
+            described_class.run(xml)
+          end
+
+          it "returns the values the controller needs to handle the request" do
+            expect(WorldpayRefundService).to receive(:run).with(args) { response_values }
+
+            expect(described_class.run(xml)).to eq(request_type.merge(response_values))
+          end
+        end
+
+        context "but it's not recognised" do
+          let(:xml) { Nokogiri::XML(File.read("spec/fixtures/unrecognised_request.xml")) }
+
+          it "raises a 'UnrecognisedWorldpayRequestError'" do
+            expect { described_class.run(xml) }.to raise_error UnrecognisedWorldpayRequestError
+          end
+        end
+      end
+    end
+  end
+end

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,29 +25,17 @@ 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) }
-    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
-      data = [
-        order_key,
-        order_value,
-        "GBP",
-        "AUTHORISED",
-        mac_secret
-      ]
-
-      Digest::MD5.hexdigest(data.join).to_s
-    end
+    let(:mac) { Digest::MD5.hexdigest(mac_data.join).to_s }
 
     let(:query_string) do
       [
         "orderKey=#{order_key}",
-        "paymentStatus=AUTHORISED",
+        "paymentStatus=#{payment_status}",
         "paymentAmount=#{order_value}",
         "paymentCurrency=GBP",
         "mac=#{mac}",
@@ -53,91 +43,228 @@ module DefraRubyMocks
       ].join("&")
     end
 
+    let(:args) do
+      {
+        success_url: success_url,
+        failure_url: failure_url,
+        pending_url: pending_url,
+        cancel_url: cancel_url,
+        error_url: error_url
+      }
+    end
+
     describe ".run" do
       context "when the request comes from the waste-carriers-front-office" do
         let(:success_url) { "http://example.com/fo/#{reference}/worldpay/success" }
+        let(:failure_url) { "http://example.com/fo/#{reference}/worldpay/failure" }
+        let(:pending_url) { "http://example.com/fo/#{reference}/worldpay/pending" }
+        let(:cancel_url) { "http://example.com/fo/#{reference}/worldpay/cancel" }
+        let(:error_url) { "http://example.com/fo/#{reference}/worldpay/error" }
 
         context "and is valid" do
           let(:relation) { double(:relation, first: registration) }
+          let(:mac_data) { [order_key, order_value, "GBP", payment_status, mac_secret] }
 
           it "can extract the reference from the `success_url`" do
-            described_class.run(success_url)
-
-            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(success_url))
+            expect(described_class.run(args).order_key).to eq(order_key)
+          end
+
+          context "and is for a successful payment" do
+            it "can generate a valid mac" do
+              puts "Test data #{mac_data.join}"
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{success_url}?#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
+          end
 
-            expect(params["orderKey"]).to eq(order_key)
+          context "and is for a rejected payment" do
+            let(:payment_status) { :REFUSED }
+            let(:company_name) { "Reject for the thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{failure_url}?#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
+          end
+
+          context "and is for a stuck payment" do
+            let(:payment_status) { :STUCK }
+            let(:company_name) { "Give me a stuck thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a status of :STUCK" do
+              expect(described_class.run(args).status).to eq(:STUCK)
+            end
           end
 
-          it "can generate a valid mac" do
-            params = parse_for_params(described_class.run(success_url))
+          context "and is for a pending payment" do
+            let(:payment_status) { :SENT_FOR_AUTHORISATION }
+            let(:company_name) { "Pending for the thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{pending_url}?#{query_string}"
 
-            expect(params["mac"]).to eq(mac)
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
           end
 
-          it "returns a url in the expected format" do
-            expected_response = "#{success_url}?#{query_string}"
+          context "and is for a cancelled payment" do
+            let(:payment_status) { :CANCELLED }
+            let(:company_name) { "Cancel the thing" }
+            let(:mac_data) { [order_key, order_value, "GBP", mac_secret] }
 
-            expect(described_class.run(success_url)).to eq(expected_response)
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{cancel_url}?#{query_string}"
+
+              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 an errored payment" do
+            let(:payment_status) { :ERROR }
+            let(:company_name) { "Error the thing" }
 
-          it "causes an error" do
-            expect { described_class.run(success_url) }.to raise_error MissingRegistrationError
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{error_url}?#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            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" }
+        let(:pending_url) { "http://example.com/your-registration/#{reference}/worldpay/pending/54321/NEWREG?locale=en" }
+        let(:cancel_url) { "http://example.com/your-registration/#{reference}/worldpay/cancel/54321/NEWREG?locale=en" }
+        let(:error_url) { "http://example.com/your-registration/#{reference}/worldpay/error/54321/NEWREG?locale=en" }
 
         context "and is valid" do
           let(:relation) { double(:relation, first: registration) }
+          let(:mac_data) { [order_key, order_value, "GBP", payment_status, mac_secret] }
 
           it "can extract the reference from the `success_url`" do
-            described_class.run(success_url)
-
-            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(success_url))
+            expect(described_class.run(args).order_key).to eq(order_key)
+          end
 
-            expect(params["orderKey"]).to eq(order_key)
+          context "and is for a successful payment" do
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{success_url}&#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
           end
 
-          it "can generate a valid mac" do
-            params = parse_for_params(described_class.run(success_url))
+          context "and is for a rejected payment" do
+            let(:payment_status) { :REFUSED }
+            let(:company_name) { "Reject for the thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
 
-            expect(params["mac"]).to eq(mac)
+            it "returns a url in the expected format" do
+              expected_response_url = "#{failure_url}&#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
           end
 
-          it "returns a url in the expected format" do
-            expected_response = "#{success_url}&#{query_string}"
+          context "and is for a stuck payment" do
+            let(:payment_status) { :STUCK }
+            let(:company_name) { "Give me a stuck thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
 
-            expect(described_class.run(success_url)).to eq(expected_response)
+            it "returns a status of :STUCK" do
+              expect(described_class.run(args).status).to eq(:STUCK)
+            end
           end
-        end
 
-        context "but the registration does not exist" do
-          let(:relation) { double(:relation, first: nil) }
+          context "and is for a pending payment" do
+            let(:payment_status) { :SENT_FOR_AUTHORISATION }
+            let(:company_name) { "Pending for the thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{pending_url}&#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
+          end
+
+          context "and is for a cancelled payment" do
+            let(:payment_status) { :CANCELLED }
+            let(:company_name) { "Cancel the thing" }
+            let(:mac_data) { [order_key, order_value, "GBP", mac_secret] }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{cancel_url}&#{query_string}"
+
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
+          end
+
+          context "and is for an errored payment" do
+            let(:payment_status) { :ERROR }
+            let(:company_name) { "Error the thing" }
+
+            it "can generate a valid mac" do
+              expect(described_class.run(args).mac).to eq(mac)
+            end
+
+            it "returns a url in the expected format" do
+              expected_response_url = "#{error_url}&#{query_string}"
 
-          it "causes an error" do
-            expect { described_class.run(success_url) }.to raise_error MissingRegistrationError
+              expect(described_class.run(args).url).to eq(expected_response_url)
+            end
           end
         end
       end