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

defra_ruby_mocks 2.3.2 → 2.4.0

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