defra_ruby_mocks 2.3.3 → 2.4.1

data/spec/services/worldpay_request_handler_service_spec.rb

@@ -1,79 +0,0 @@
-# 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/files/worldpay/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/files/worldpay/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/files/worldpay/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

@@ -1,120 +0,0 @@
-# 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
-
-        context "when the company name is not populated" do
-          let(:company_name) { nil }
-
-          it "returns the object" do
-            expect(described_class.run(args).resource).to eq(resource)
-          end
-        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

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-
-  RSpec.describe WorldpayResponseService do
-    before(:each) do
-      Helpers::Configuration.prep_for_tests
-      DefraRubyMocks.configure do |config|
-        config.worldpay_admin_code = admin_code
-        config.worldpay_merchant_code = merchant_code
-        config.worldpay_mac_secret = mac_secret
-      end
-
-      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" }
-    let(:reference) { "12345" }
-    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(:order) { double(:order, order_code: order_code, total_amount: order_value) }
-
-    let(:mac) { Digest::MD5.hexdigest(mac_data.join).to_s }
-
-    let(:query_string) do
-      [
-        "orderKey=#{order_key}",
-        "paymentStatus=#{payment_status}",
-        "paymentAmount=#{order_value}",
-        "paymentCurrency=GBP",
-        "mac=#{mac}",
-        "source=WP"
-      ].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
-            expect(described_class.run(args).reference).to eq(reference)
-          end
-
-          it "can generate a valid order key" do
-            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
-              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
-
-            context "and the company name is blank" do
-              let(:company_name) { nil }
-
-              it "can extract the reference from the `success_url`" do
-                expect(described_class.run(args).reference).to eq(reference)
-              end
-            end
-          end
-
-          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
-
-          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}"
-
-              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
-        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
-            expect(described_class.run(args).reference).to eq(reference)
-          end
-
-          it "can generate a valid order key" do
-            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
-              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
-
-          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
-
-          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}"
-
-              expect(described_class.run(args).url).to eq(expected_response_url)
-            end
-          end
-        end
-      end
-    end
-  end
-end