defra_ruby_mocks 2.3.3 → 2.4.0

data/app/services/defra_ruby_mocks/worldpay_request_handler_service.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module DefraRubyMocks
-  class WorldpayRequestHandlerService < BaseService
-    def run(xml)
-      arguments = {
-        merchant_code: extract_merchant_code(xml),
-        xml: xml
-      }
-
-      generate_response(arguments)
-    end
-
-    private
-
-    def extract_merchant_code(xml)
-      payment_service = xml.at_xpath("//paymentService")
-      payment_service.attribute("merchantCode").text
-    end
-
-    def generate_response(arguments)
-      return WorldpayPaymentService.run(arguments).merge(request_type: :payment) if payment_request?(arguments[:xml])
-      return WorldpayRefundService.run(arguments).merge(request_type: :refund) if refund_request?(arguments[:xml])
-
-      raise UnrecognisedWorldpayRequestError
-    end
-
-    def payment_request?(xml)
-      submit = xml.at_xpath("//submit")
-
-      !submit.nil?
-    end
-
-    def refund_request?(xml)
-      modify = xml.at_xpath("//modify")
-
-      !modify.nil?
-    end
-  end
-end

data/app/services/defra_ruby_mocks/worldpay_resource_service.rb

@@ -1,55 +0,0 @@
-# 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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module DefraRubyMocks
-  class WorldpayResponseService < BaseService
-
-    def run(success_url:, failure_url:, pending_url:, cancel_url:, error_url:)
-      urls = {
-        success: success_url,
-        failure: failure_url,
-        pending: pending_url,
-        cancel: cancel_url,
-        error: error_url
-      }
-
-      parse_reference(urls[:success])
-      @resource = WorldpayResourceService.run(reference: @reference)
-
-      generate_response(urls)
-    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("/")
-
-      if parts[1].downcase == "your-registration"
-        # ["", "your-registration", "xP2zj9nqWYI0SAsMtGZn6w", "worldpay", "success", "1577812071", "NEWREG"]
-        @reference = parts[-5]
-        @url_format = :old
-      else
-        # ["", "fo", "jq6sTt2RQguAu4ZyKFfRg9zm", "worldpay", "success"]
-        @reference = parts[-3]
-        @url_format = :new
-      end
-    end
-
-    def order_key
-      [
-        DefraRubyMocks.configuration.worldpay_admin_code,
-        DefraRubyMocks.configuration.worldpay_merchant_code,
-        @resource.order.order_code
-      ].join("^")
-    end
-
-    def order_value
-      @resource.order.total_amount.to_s
-    end
-
-    def payment_status
-      return :AUTHORISED unless @resource.company_name
-
-      return :REFUSED if @resource.company_name.include?("reject")
-      return :STUCK if @resource.company_name.include?("stuck")
-      return :SENT_FOR_AUTHORISATION if @resource.company_name.include?("pending")
-      return :CANCELLED if @resource.company_name.include?("cancel")
-      return :ERROR if @resource.company_name.include?("error")
-
-      :AUTHORISED
-    end
-
-    def url(payment_status, urls)
-      return urls[:failure] if %i[REFUSED STUCK].include?(payment_status)
-      return urls[:pending] if payment_status == :SENT_FOR_AUTHORISATION
-      return urls[:cancel] if payment_status == :CANCELLED
-      return urls[:error] if payment_status == :ERROR
-
-      urls[:success]
-    end
-
-    # Generate a mac that matches what Worldpay would generate
-    #
-    # For whatever reason, if the payment is cancelled by the user Worldpay does
-    # not include the payment status in the mac it generates. Plus the order of
-    # things in the array is important.
-    def generate_mac(status)
-      data = [
-        order_key,
-        order_value,
-        "GBP"
-      ]
-      data << status unless status == :CANCELLED
-      data << DefraRubyMocks.configuration.worldpay_mac_secret
-
-      Digest::MD5.hexdigest(data.join).to_s
-    end
-
-    def generate_response(urls)
-      status = payment_status
-
-      WorldpayResponse.new(
-        url(status, urls),
-        @url_format == :new ? "?" : "&",
-        order_key,
-        generate_mac(status),
-        order_value,
-        status,
-        @reference
-      )
-    end
-  end
-end

data/app/views/defra_ruby_mocks/worldpay/payment_request.xml.erb

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE paymentService PUBLIC "-//WorldPay//DTD WorldPay PaymentService v1//EN"
-        "http://dtd.worldpay.com/paymentService_v1.dtd">
-<paymentService version="1.4" merchantCode="<%= @values[:merchant_code] %>"><reply><orderStatus orderCode="<%= @values[:order_code] %>"><reference id="<%= @values[:id] %>"><%= @values[:url] %></reference></orderStatus></reply></paymentService>

data/app/views/defra_ruby_mocks/worldpay/refund_request.xml.erb

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE paymentService PUBLIC "-//WorldPay//DTD WorldPay PaymentService v1//EN"
-                                "http://dtd.worldpay.com/paymentService_v1.dtd">
-<paymentService version="1.4" merchantCode="<%= @values[:merchant_code] %>"><reply><ok><refundReceived orderCode="<%= @values[:order_code] %>"><amount value="<%= @values[:refund_value] %>" currencyCode="<%= @values[:currency_code] %>" exponent="<%= @values[:exponent] %>" debitCreditIndicator="credit"/></refundReceived></ok></reply></paymentService>

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

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

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

data/spec/fixtures/files/worldpay/payment_request_invalid.xml

@@ -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/files/worldpay/payment_request_valid.xml

@@ -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/files/worldpay/refund_request_invalid.xml

@@ -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/files/worldpay/refund_request_valid.xml

@@ -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/files/worldpay/unrecognised_request.xml

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

@@ -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/files/worldpay/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/files/worldpay/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/files/worldpay/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

@@ -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/files/worldpay/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/files/worldpay/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

@@ -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/files/worldpay/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/files/worldpay/refund_request_invalid.xml")) }
-
-        it "raises an error" do
-          expect { described_class.run(args) }.to raise_error StandardError
-        end
-      end
-    end
-  end
-end