RubyGems - defra_ruby_mocks - Versions diffs - 2.3.2 → 2.4.0 - Mend

defra_ruby_mocks 2.3.2 → 2.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

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

@@ -1,37 +0,0 @@
-<!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/unrecognised_worldpay_request_error.rb DELETED Viewed

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-module DefraRubyMocks
-  class UnrecognisedWorldpayRequestError < StandardError; end
-end

data/spec/fixtures/payment_request_invalid.xml DELETED Viewed

@@ -1,6 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE paymentService PUBLIC "-//WorldPay/DTD WorldPay PaymentService v1/EN" "http://dtd.worldpay.com/paymentService_v1.dtd">
-<paymentService version="1.4">
-  <submit>
-  </submit>
-</paymentService>

data/spec/fixtures/payment_request_valid.xml DELETED Viewed

@@ -1,30 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE paymentService PUBLIC "-//WorldPay/DTD WorldPay PaymentService v1/EN" "http://dtd.worldpay.com/paymentService_v1.dtd">
-<paymentService version="1.4" merchantCode="MERCHME">
-  <submit>
-    <order orderCode="1577726052">
-      <description>Your Waste Carrier Registration CBDU2</description>
-      <amount currencyCode="GBP" value="10500" exponent="2"/>
-      <orderContent>Waste Carrier Registration renewal: CBDU2 for Booth Mcdaniel Associates</orderContent>
-      <paymentMethodMask>
-        <include code="VISA-SSL"/>
-        <include code="MAESTRO-SSL"/>
-        <include code="ECMC-SSL"/>
-      </paymentMethodMask>
-      <shopper>
-        <shopperEmailAddress>vucij@example.com</shopperEmailAddress>
-      </shopper>
-      <billingAddress>
-        <address>
-          <firstName>Bell</firstName>
-          <lastName>Cruz</lastName>
-          <address1>HARMSEN GROUP DEANERY ROAD</address1>
-          <address2/>
-          <postalCode>BS1 5AH</postalCode>
-          <city>BRISTOL</city>
-          <countryCode>GB</countryCode>
-        </address>
-      </billingAddress>
-    </order>
-  </submit>
-</paymentService>

data/spec/fixtures/refund_request_invalid.xml DELETED Viewed

@@ -1,6 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE paymentService PUBLIC '-//WorldPay/DTD WorldPay PaymentService v1/EN' 'http://dtd.worldpay.com/paymentService_v1.dtd'>
-<paymentService version="1.4">
-  <modify>
-  </modify>
-</paymentService>

data/spec/fixtures/refund_request_valid.xml DELETED Viewed

@@ -1,11 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE paymentService PUBLIC '-//WorldPay/DTD WorldPay PaymentService v1/EN' 'http://dtd.worldpay.com/paymentService_v1.dtd'>
-<paymentService version="1.4" merchantCode="MERCHME">
-  <modify>
-    <orderModification orderCode="1579644835">
-      <refund>
-        <amount value="2500" currencyCode="GBP" exponent="2"/>
-      </refund>
-    </orderModification>
-  </modify>
-</paymentService>

data/spec/fixtures/unrecognised_request.xml DELETED Viewed

@@ -1,6 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE paymentService PUBLIC '-//WorldPay/DTD WorldPay PaymentService v1/EN' 'http://dtd.worldpay.com/paymentService_v1.dtd'>
-<paymentService version="1.4" merchantCode="MERCHME">
-  <boom>
-  </boom>
-</paymentService>

data/spec/requests/worldpay_spec.rb DELETED Viewed

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-require "rails_helper"
-module DefraRubyMocks
-  RSpec.describe "Worldpay", type: :request do
-    after(:all) { Helpers::Configuration.reset_for_tests }
-    context "when mocks are enabled" do
-      before(:each) do
-        Helpers::Configuration.prep_for_tests
-        DefraRubyMocks.configure do |config|
-          config.worldpay_admin_code = "admincode1"
-          config.worldpay_mac_secret = "macsecret1"
-          config.worldpay_domain = "http://localhost:3000/defra_ruby_mocks"
-        end
-      end
-      context "#payments_service" do
-        let(:path) { "/defra_ruby_mocks/worldpay/payments-service" }
-        context "when a payment request is received" do
-          context "and the request is valid" do
-            let(:data) { File.read("spec/fixtures/payment_request_valid.xml") }
-            it "returns an XML response with a 200 code" do
-              post path, headers: { "RAW_POST_DATA" => data }
-              expect(response.media_type).to eq("application/xml")
-              expect(response.code).to eq("200")
-              expect(response.body).to be_xml
-            end
-          end
-          context "and the request is invalid" do
-            let(:data) { File.read("spec/fixtures/payment_request_invalid.xml") }
-            it "returns a response with a 500 code" do
-              post path, headers: { "RAW_POST_DATA" => data }
-              expect(response.code).to eq("500")
-            end
-          end
-        end
-        context "when a refund request is received" do
-          context "and the request is valid" do
-            let(:data) { File.read("spec/fixtures/refund_request_valid.xml") }
-            it "returns an XML response with a 200 code" do
-              post path, headers: { "RAW_POST_DATA" => data }
-              expect(response.media_type).to eq("application/xml")
-              expect(response.code).to eq("200")
-              expect(response.body).to be_xml
-            end
-          end
-        end
-      end
-      context "#dispatcher" do
-        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
-          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
-              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" }
-            it "returns a response with a 500 code" do
-              get path
-              expect(response.code).to eq("500")
-            end
-          end
-        end
-      end
-    end
-    context "when mocks are disabled" do
-      before(:each) { DefraRubyMocks.configuration.enable = false }
-      context "#payments_service" do
-        let(:path) { "/defra_ruby_mocks/worldpay/payments-service" }
-        it "cannot load the page" do
-          expect { get path }.to raise_error(ActionController::RoutingError)
-        end
-      end
-      context "#dispatcher" do
-        let(:path) { "/defra_ruby_mocks/worldpay/dispatcher" }
-        it "cannot load the page" do
-          expect { get path }.to raise_error(ActionController::RoutingError)
-        end
-      end
-    end
-  end
-end

data/spec/services/worldpay_payment_service_spec.rb DELETED Viewed

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-require "rails_helper"
-module DefraRubyMocks
-  RSpec.describe WorldpayPaymentService do
-    describe ".run" do
-      after(:each) { Helpers::Configuration.reset_for_tests }
-      let(:merchant_code) { "MERCHME" }
-      let(:args) { { merchant_code: merchant_code, xml: xml } }
-      context "when the mocks config is missing a worldpay domain" do
-        let(:xml) { nil }
-        it "raises a 'InvalidConfigError'" do
-          expect { described_class.run(args) }.to raise_error InvalidConfigError
-        end
-      end
-      context "when the XML is valid" do
-        before(:each) do
-          DefraRubyMocks.configure do |config|
-            config.worldpay_domain = "http://localhost:3000/defra_ruby_mocks"
-          end
-        end
-        let(:xml) { Nokogiri::XML(File.read("spec/fixtures/payment_request_valid.xml")) }
-        context "the result it returns" do
-          it "is a hash" do
-            expect(described_class.run(args)).to be_an_instance_of(Hash)
-          end
-          it "contains 4 values" do
-            result = described_class.run(args).length
-            expect(result).to eq(4)
-          end
-          it "has the merchant code passed in" do
-            result = described_class.run(args)[:merchant_code]
-            expect(result).to eq(merchant_code)
-          end
-          it "has an order code extracted from the XML" do
-            result = described_class.run(args)[:order_code]
-            expect(result).to eq("1577726052")
-          end
-          context "has a generated ID which is" do
-            it "10 characters long" do
-              result = described_class.run(args)[:id]
-              expect(result.length).to eq(10)
-            end
-            it "only made up of the digits 0 to 9" do
-              result = described_class.run(args)[:id]
-              expect(result.scan(/\D/).empty?).to be_truthy
-            end
-            it "different each time" do
-              results = []
-              3.times do
-                results << described_class.run(args)[:id]
-              end
-              expect(results.uniq.length).to eq(results.length)
-            end
-          end
-          context "has a url" do
-            it "based on the configured domain, and extracted merchant and order codes" do
-              result = described_class.run(args)[:url]
-              expect(result).to eq("http://localhost:3000/defra_ruby_mocks/worldpay/dispatcher?OrderKey=MERCHME%5E1577726052")
-            end
-          end
-        end
-      end
-      context "when the XML is invalid" do
-        let(:xml) { Nokogiri::XML(File.read("spec/fixtures/payment_request_invalid.xml")) }
-        it "raises an error" do
-          expect { described_class.run(args) }.to raise_error StandardError
-        end
-      end
-    end
-  end
-end

data/spec/services/worldpay_refund_service_spec.rb DELETED Viewed

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-require "rails_helper"
-module DefraRubyMocks
-  RSpec.describe WorldpayRefundService do
-    describe ".run" do
-      let(:merchant_code) { "MERCHME" }
-      let(:args) { { merchant_code: merchant_code, xml: xml } }
-      context "when the XML is valid" do
-        let(:xml) { Nokogiri::XML(File.read("spec/fixtures/refund_request_valid.xml")) }
-        context "the result it returns" do
-          it "is a hash" do
-            expect(described_class.run(args)).to be_an_instance_of(Hash)
-          end
-          it "contains 5 values" do
-            result = described_class.run(args).length
-            expect(result).to eq(5)
-          end
-          it "has the merchant code passed in" do
-            result = described_class.run(args)[:merchant_code]
-            expect(result).to eq(merchant_code)
-          end
-          it "has an order code extracted from the XML" do
-            result = described_class.run(args)[:order_code]
-            expect(result).to eq("1579644835")
-          end
-          it "has the refund value extracted from the XML" do
-            result = described_class.run(args)[:refund_value]
-            expect(result).to eq("2500")
-          end
-          it "has a currency code extracted from the XML" do
-            result = described_class.run(args)[:currency_code]
-            expect(result).to eq("GBP")
-          end
-          it "has the exponent extracted from the XML" do
-            result = described_class.run(args)[:exponent]
-            expect(result).to eq("2")
-          end
-        end
-      end
-      context "when the XML is invalid" do
-        let(:xml) { Nokogiri::XML(File.read("spec/fixtures/refund_request_invalid.xml")) }
-        it "raises an error" do
-          expect { described_class.run(args) }.to raise_error StandardError
-        end
-      end
-    end
-  end
-end

data/spec/services/worldpay_request_handler_service_spec.rb DELETED Viewed

@@ -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/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 DELETED Viewed

@@ -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