defra_ruby_mocks 1.2.0 → 2.0.0

data/spec/requests/worldpay_spec.rb

@@ -24,9 +24,9 @@ module DefraRubyMocks
             let(:data) { File.read("spec/fixtures/payment_request_valid.xml") }
 
             it "returns an XML response with a 200 code" do
-              get path, {}, "RAW_POST_DATA" => data
+              get path, headers: { "RAW_POST_DATA" => data }
 
-              expect(response.content_type).to eq("application/xml")
+              expect(response.media_type).to eq("application/xml")
               expect(response.code).to eq("200")
               expect(response.body).to be_xml
             end
@@ -36,7 +36,7 @@ module DefraRubyMocks
             let(:data) { File.read("spec/fixtures/payment_request_invalid.xml") }
 
             it "returns a response with a 500 code" do
-              get path, {}, "RAW_POST_DATA" => data
+              get path, headers: { "RAW_POST_DATA" => data }
 
               expect(response.code).to eq("500")
             end
@@ -48,9 +48,9 @@ module DefraRubyMocks
             let(:data) { File.read("spec/fixtures/refund_request_valid.xml") }
 
             it "returns an XML response with a 200 code" do
-              get path, {}, "RAW_POST_DATA" => data
+              get path, headers: { "RAW_POST_DATA" => data }
 
-              expect(response.content_type).to eq("application/xml")
+              expect(response.media_type).to eq("application/xml")
               expect(response.code).to eq("200")
               expect(response.body).to be_xml
             end
@@ -59,30 +59,74 @@ module DefraRubyMocks
       end
 
       context "#dispatcher" do
-        let(:relation) { double(:relation, first: registration) }
-        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: "987654", total_amount: 105_00) }
-
-        let(:path) { "/defra_ruby_mocks/worldpay/dispatcher?successURL=#{CGI.escape(success_url)}" }
+        let(:success_url) { "http://example.com/fo/12345/worldpay/success" }
+        let(:failure_url) { "http://example.com/fo/12345/worldpay/failure" }
+        let(:pending_url) { "http://example.com/fo/12345/worldpay/pending" }
+        let(:cancel_url) { "http://example.com/fo/12345/worldpay/cancel" }
+        let(:error_url) { "http://example.com/fo/12345/worldpay/error" }
+        let(:response_url) { "#{success_url}?orderKey=admincode1^^987654&paymentStatus=#{status}&paymentAmount=10500&paymentCurrency=GBP&mac=0ba5271e1ed1b26f9bb428ef7fb536a4&source=WP" }
+        let(:path) do
+          root = "/defra_ruby_mocks/worldpay/dispatcher"
+          escaped_success = CGI.escape(success_url)
+          escaped_failure = CGI.escape(failure_url)
+          escaped_pending = CGI.escape(pending_url)
+          escaped_cancel = CGI.escape(cancel_url)
+          escaped_error = CGI.escape(error_url)
+
+          "#{root}?successURL=#{escaped_success}&failureURL=#{escaped_failure}&pendingURL=#{escaped_pending}&cancelURL=#{escaped_cancel}&errorURL=#{escaped_error}"
+        end
+        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" }
-          let(:success_url) { "http://example.com/fo/12345/worldpay/success" }
+          before(:each) do
+            allow(WorldpayResponseService).to receive(:run)
+              .with(
+                success_url: success_url,
+                failure_url: failure_url,
+                pending_url: pending_url,
+                cancel_url: cancel_url,
+                error_url: error_url
+              ) { service_response }
+          end
+
+          context "and a response is expected" do
+            let(:status) { "AUTHORISED" }
+
+            it "redirects the user with a 300 code" do
+              get path
 
-          it "redirects the user with a 300 code" do
-            expect(::WasteCarriersEngine::TransientRegistration).to receive(:where) { relation }
+              expect(response).to redirect_to(response_url)
+              expect(response.code).to eq("302")
+            end
+          end
 
-            get path
+          context "and a response is not expected" do
+            let(:status) { :STUCK }
+
+            it "renders the Worldpay stuck page" do
+              get path
 
-            expect(response).to redirect_to("#{success_url}?#{response_params}")
-            expect(response.code).to eq("302")
+              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,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