defra_ruby_mocks 2.4.2 → 4.1.0

data/spec/lib/configuration_spec.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module DefraRubyMocks
-  RSpec.describe Configuration do
-    let(:subject) { described_class.new }
-
-    describe "#enable=" do
-      context "when passed true as boolean" do
-        it "sets enable to 'true'" do
-          subject.enable = true
-
-          expect(subject.enabled?).to be(true)
-        end
-      end
-
-      context "when passed false as a boolean" do
-        it "sets enable to 'false'" do
-          subject.enable = false
-
-          expect(subject.enabled?).to be(false)
-        end
-      end
-
-      context "when passed true as string" do
-        it "sets enable to 'true'" do
-          subject.enable = "true"
-
-          expect(subject.enabled?).to be(true)
-        end
-      end
-
-      context "when passed false as a string" do
-        it "sets enable to 'false'" do
-          subject.enable = "false"
-
-          expect(subject.enabled?).to be(false)
-        end
-      end
-    end
-
-    describe "#delay=" do
-      context "when passed 200 as an integer" do
-        it "sets delay to 200" do
-          subject.delay = 200
-
-          expect(subject.delay).to be(200)
-        end
-      end
-
-      context "when passed 200 as a string" do
-        it "sets delay to 200" do
-          subject.delay = "200"
-
-          expect(subject.delay).to be(200)
-        end
-      end
-
-      context "when passed a string that's not a number" do
-        it "sets delay to its default" do
-          subject.delay = ""
-
-          expect(subject.delay).to be(Configuration::DEFAULT_DELAY)
-        end
-      end
-
-      context "when passed nil" do
-        it "sets delay to its default" do
-          subject.delay = nil
-
-          expect(subject.delay).to be(Configuration::DEFAULT_DELAY)
-        end
-      end
-    end
-  end
-end

data/spec/rails_helper.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# This file is copied to spec/ when you run 'rails generate rspec:install'
-require "spec_helper"
-ENV["RAILS_ENV"] ||= "test"
-require File.expand_path("dummy/config/environment", __dir__)
-
-# Prevent database truncation if the environment is production
-abort("The Rails environment is running in production mode!") if Rails.env.production?
-require "rspec/rails"
-# Add additional requires below this line. Rails is not loaded until this point!
-
-# Requires supporting ruby files with custom matchers and macros, etc, in
-# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
-# run as spec files by default. This means that files in spec/support that end
-# in _spec.rb will both be required and run as specs, causing the specs to be
-# run twice. It is recommended that you do not name files matching this glob to
-# end with _spec.rb. You can configure this pattern with the --pattern
-# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
-#
-# We make an exception for simplecov because that will already have been
-# required and run at the very top of spec_helper.rb
-support_files = Dir["./spec/support/**/*.rb"].reject { |file| file == "./spec/support/simplecov.rb" }
-support_files.each { |f| require f }
-
-RSpec.configure do |config|
-  # RSpec Rails can automatically mix in different behaviours to your tests
-  # based on their file location, for example enabling you to call `get` and
-  # `post` in specs under `spec/controllers`.
-  #
-  # You can disable this behaviour by removing the line below, and instead
-  # explicitly tag your specs with their type, e.g.:
-  #
-  #     RSpec.describe UsersController, :type => :controller do
-  #       # ...
-  #     end
-  #
-  # The different available types are documented in the features, such as in
-  # https://relishapp.com/rspec/rspec-rails/docs
-  config.infer_spec_type_from_file_location!
-
-  # Filter lines from Rails gems in backtraces.
-  config.filter_rails_from_backtrace!
-  # arbitrary gems may also be filtered via:
-  # config.filter_gems_from_backtrace("gem name")
-end

data/spec/requests/company_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-  RSpec.describe "Company", type: :request do
-    after(:all) { Helpers::Configuration.reset_for_tests }
-
-    let(:path) { "/defra_ruby_mocks/company" }
-
-    context "when mocks are enabled" do
-      before(:each) { Helpers::Configuration.prep_for_tests }
-
-      context "when the company number is 99999999 for not found" do
-        let(:company_number) { "99999999" }
-
-        it "returns a JSON response with a code of 404" do
-          get "#{path}/#{company_number}"
-          content = JSON.parse(response.body)
-
-          expect(response.media_type).to eq("application/json")
-          expect(response.code).to eq("404")
-          expect(content).to include("errors")
-        end
-      end
-
-      context "when the company number is from the 'specials' list" do
-        let(:company_number) { "05868270" }
-
-        it "returns a JSON response with a 200 code and a status that isn't 'active'" do
-          get "#{path}/#{company_number}"
-
-          expect(response.media_type).to eq("application/json")
-          expect(response.code).to eq("200")
-          expect(JSON.parse(response.body).deep_symbolize_keys).to eq(
-            company_name: "Acme Industries",
-            company_status: "dissolved",
-            type: "ltd",
-            registered_office_address: {
-              address_line_1: "10 Downing St",
-              address_line_2: "Horizon House",
-              locality: "Bristol",
-              postal_code: "BS1 5AH"
-            }
-          )
-        end
-      end
-
-      context "when the company number is not from the 'specials' list" do
-        context "and it is valid" do
-          let(:company_number) { "SC247974" }
-
-          it "returns a JSON response with a 200 code and a status of 'active'" do
-            get "#{path}/#{company_number}"
-            company_status = JSON.parse(response.body)["company_status"]
-            company_type = JSON.parse(response.body)["type"]
-
-            expect(response.media_type).to eq("application/json")
-            expect(response.code).to eq("200")
-            expect(company_status).to eq("active")
-            expect(company_type).to eq("ltd")
-          end
-        end
-
-        context "and it is not valid" do
-          let(:company_number) { "foo" }
-
-          it "returns a JSON response with a 404 code" do
-            get "#{path}/#{company_number}"
-            content = JSON.parse(response.body)
-
-            expect(response.media_type).to eq("application/json")
-            expect(response.code).to eq("404")
-            expect(content).to include("errors")
-          end
-        end
-      end
-    end
-
-    context "when mocks are disabled" do
-      before(:all) { DefraRubyMocks.configuration.enable = false }
-
-      let(:company_number) { "SC247974" }
-
-      it "cannot load the page" do
-        expect { get "#{path}/#{company_number}" }.to raise_error(ActionController::RoutingError)
-      end
-    end
-
-  end
-end

data/spec/requests/govpay_spec.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-  RSpec.describe "Govpay", 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.govpay_domain = "http://localhost:3000/defra_ruby_mocks"
-        end
-
-      end
-
-      context "#create_payment" do
-        let(:path) { "/defra_ruby_mocks/govpay/v1/payments" }
-        # Use an example from the Govpay documentation
-        let(:payment_request) do
-          {
-            amount: 14_500,
-            reference: "12345",
-            description: "Pay your council tax",
-            return_url: "https://your.service.gov.uk/completed"
-          }
-        end
-
-        context "when the request is valid" do
-
-          it "returns a valid success response" do
-            post path, params: payment_request.as_json
-
-            expect(response.media_type).to eq("application/json")
-            expect(response.code).to eq("200")
-            response_json = JSON.parse(response.body)
-            expect(response_json["reference"]).to eq payment_request[:reference]
-            expect(response_json["amount"]).to eq payment_request[:amount]
-            expect(response_json["description"]).to eq payment_request[:description]
-            expect(response_json["_links"]["next_url"]["href"]).to eq payment_request[:return_url]
-          end
-
-          it "enqueues a job to perform the payment callback" do
-            ActiveJob::Base.queue_adapter = :test
-            expect { post path, params: payment_request.as_json }.to have_enqueued_job(GovpayPaymentCallbackJob)
-          end
-        end
-
-        context "when the request is missing a mandatory parameter" do
-          before { payment_request[:amount] = nil }
-
-          it "returns a HTTP 500 response" do
-            post path, params: payment_request.as_json
-
-            expect(response.code).to eq "500"
-          end
-        end
-      end
-
-      describe "#payment_details" do
-        let(:path) { "/defra_ruby_mocks/govpay/v1/payments/#{payment_id}" }
-
-        context "when the payment id is valid" do
-          before do
-            allow(GovpayGetPaymentService).to receive(:run)
-              .with(payment_id)
-              .and_return(JSON.parse(File.read("spec/fixtures/files/govpay/get_payment_response_success.json")))
-          end
-
-          let(:payment_id) { "12345678901234567890123456" }
-
-          it "returns a valid success response" do
-            get path
-
-            expect(response.code).to eq "200"
-          end
-        end
-
-        context "when the payment id is not valid" do
-          before do
-            allow(GovpayGetPaymentService).to receive(:run)
-              .with(payment_id)
-              .and_return(JSON.parse(File.read("spec/fixtures/files/govpay/get_payment_response_error.json")))
-          end
-
-          let(:payment_id) { "0" }
-
-          it "returns a 422 response" do
-            get path
-
-            expect(response.code).to eq "422"
-          end
-        end
-      end
-
-      describe "#create_refund" do
-        let(:payment_id) { "12345678901234567890123456" }
-        let(:path) { "/defra_ruby_mocks/govpay/v1/payments/#{payment_id}/refunds" }
-        let(:refund_request) do
-          {
-            "amount": 2000,
-            "refund_amount_available": 5000
-          }
-        end
-
-        context "when the request is missing a mandatory parameter" do
-          before { refund_request[:refund_amount_available] = nil }
-
-          it "returns a HTTP 500 response" do
-            post path, params: refund_request.as_json
-
-            expect(response.code).to eq "500"
-          end
-        end
-
-        context "with a valid request" do
-          it "returns a valid success response" do
-            post path, params: refund_request.as_json
-
-            expect(response.code).to eq "200"
-          end
-        end
-      end
-
-      describe "#refund_details" do
-        let(:payment_id) { "12345678901234567890123456" }
-        let(:refund_id) { "j6se0f2o427g28g8yg3u3i" }
-        let(:path) { "/defra_ruby_mocks/govpay/v1/payments/#{payment_id}/refunds/#{refund_id}" }
-
-        context "with a valid request" do
-          it "returns a valid success response" do
-            get path
-
-            expect(response.code).to eq "200"
-          end
-        end
-      end
-    end
-
-    context "when mocks are disabled" do
-      before(:each) { DefraRubyMocks.configuration.enable = false }
-      let(:payment_id) { Faker::Alphanumeric.alphanumeric(number: 26) }
-
-      context "POST #govpay_payments" do
-        let(:path) { "/defra_ruby_mocks/govpay/payments" }
-
-        it "cannot load the page" do
-          expect { post path }.to raise_error(ActionController::RoutingError)
-        end
-      end
-
-      context "GET #govpay_payments" do
-        let(:path) { "/defra_ruby_mocks/govpay/payments/#{payment_id}" }
-
-        it "cannot load the page" do
-          expect { get path }.to raise_error(ActionController::RoutingError)
-        end
-      end
-
-      context "#govpay_refunds" do
-        let(:path) { "/defra_ruby_mocks/govpay/#{payment_id}/refunds" }
-
-        it "cannot load the page" do
-          expect { post path }.to raise_error(ActionController::RoutingError)
-        end
-      end
-    end
-  end
-end

data/spec/requests/officers_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-  RSpec.describe "Officers", type: :request do
-    after(:all) { Helpers::Configuration.reset_for_tests }
-
-    let(:path) {  "/defra_ruby_mocks/company/company-no/officers" }
-
-    context "when mocks are enabled" do
-      before(:each) { Helpers::Configuration.prep_for_tests }
-
-      it "returns a JSON response" do
-        get path
-
-        expect(response.media_type).to eq("application/json")
-        expect(response.code).to eq("200")
-
-        expect(JSON.parse(response.body).deep_symbolize_keys[:items][0]).to eq(
-          {
-            name: "APPLE, Alice",
-            officer_role: "director"
-          }
-        )
-      end
-    end
-
-    context "when mocks are disabled" do
-      before(:all) { DefraRubyMocks.configuration.enable = false }
-
-      it "cannot load the page" do
-        expect { get path }.to raise_error(ActionController::RoutingError)
-      end
-    end
-  end
-end

data/spec/services/companies_house_service_spec.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-  RSpec.describe CompaniesHouseService do
-    describe ".run" do
-      subject { described_class.run(company_number) }
-
-      context "when the company number is 99999999 for not found" do
-        let(:company_number) { "99999999" }
-
-        it "raises a NotFoundError" do
-          expect { subject }.to raise_error(NotFoundError)
-        end
-      end
-
-      context "when the company number is from the 'specials' list" do
-        specials = CompaniesHouseService.special_company_numbers
-
-        specials.each do |company_number, status|
-          context "and the number is #{company_number}" do
-            let(:company_number) { company_number }
-
-            it "returns a company_status of '#{status}'" do
-              expect(subject.company_status).to eq(status)
-            end
-
-            it "returns a company_type of 'ltd'" do
-              expect(subject.company_type).to eq("ltd")
-            end
-          end
-        end
-      end
-
-      context "when the company is an LLP" do
-        CompaniesHouseService.llp_company_numbers.each do |company_number|
-          let(:company_number) { company_number }
-
-          it "returns a company_status of 'active'" do
-            expect(subject.company_status).to eq("active")
-          end
-
-          it "returns a company_type of 'llp'" do
-            expect(subject.company_type).to eq("llp")
-          end
-        end
-      end
-
-      context "when the company number is not from the 'specials' list" do
-        context "and it is valid" do
-          let(:company_number) { "SC247974" }
-
-          it "returns a company_status of 'active'" do
-            expect(subject.company_status).to eq("active")
-          end
-        end
-
-        context "and it is not valid" do
-          let(:company_number) { "foo" }
-
-          it "raises a NotFoundError" do
-            expect { subject }.to raise_error(NotFoundError)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/services/govpay_create_payment_service_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-
-  RSpec.describe GovpayCreatePaymentService do
-
-    before(:each) do
-      Helpers::Configuration.prep_for_tests
-      DefraRubyMocks.configure do |config|
-        config.govpay_domain = "http://localhost:3000/defra_ruby_mocks"
-      end
-    end
-
-    let(:amount) { Faker::Number.number(digits: 4) }
-    let(:description) { Faker::Lorem.sentence }
-    let(:return_url) { Faker::Internet.url }
-
-    describe ".run" do
-
-      subject { described_class.run(amount: amount, description: description, return_url: return_url).deep_symbolize_keys }
-
-      context "for a valid payment request" do
-
-        it "returns a payment response with the order amount" do
-          expect(subject[:amount]).to eq(amount)
-        end
-
-        it "returns a payment response with the description" do
-          expect(subject[:description]).to eq(description)
-        end
-
-        it "returns a payment response with the return_url" do
-          expect(subject[:_links][:next_url][:href]).to eq(return_url)
-        end
-
-        it "returns the expected status" do
-          expect(subject[:state][:status]).to eq("created")
-        end
-      end
-    end
-  end
-end

data/spec/services/govpay_get_payment_service_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-
-  RSpec.describe GovpayGetPaymentService do
-    before { Helpers::Configuration.prep_for_tests }
-
-    let(:order_value) { Faker::Number.number(digits: 4) }
-    let(:payment_id) { SecureRandom.hex(26) }
-
-    # Note that the service currently supports only success responses.
-    describe ".run" do
-
-      subject { described_class.run(payment_id: payment_id, amount: order_value).deep_symbolize_keys }
-
-      context "when the payment is successful" do
-
-        it "returns a payment with the order amount" do
-          expect(subject[:amount]).to eq(order_value)
-        end
-
-        it "returns the expected status" do
-          expect(subject[:state][:status]).to eq("success")
-        end
-      end
-    end
-  end
-end

data/spec/services/govpay_refund_details_service_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-
-  RSpec.describe GovpayRefundDetailsService do
-    let(:payment_id) { SecureRandom.hex(26) }
-    let(:refund_id) { SecureRandom.hex(22) }
-
-    before { Helpers::Configuration.prep_for_tests }
-
-    # Note that the service currently supports only success responses.
-    describe ".run" do
-      let(:create_request_time) { Time.zone.now }
-      let(:submitted_success_lag) { "10" }
-
-      subject { described_class.run(payment_id: payment_id, refund_id: refund_id).deep_symbolize_keys }
-
-      # the service shoud return "submitted" for up to GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG seconds, "success" thereafter
-      before do
-        Timecop.freeze(create_request_time)
-        allow(ENV).to receive(:fetch).with("GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG", any_args).and_return(submitted_success_lag)
-        FileUtils.rm_rf("#{Dir.tmpdir}/govpay_request_refund_service_last_run_time")
-      end
-
-      context "when no refund timestamp file exists" do
-        it { expect(subject[:status]).to eq "success" }
-      end
-
-      context "when a refund has been requested" do
-        before do
-          GovpayRequestRefundService.run(payment_id: payment_id, amount: 100, refund_amount_available: 100).deep_symbolize_keys
-        end
-
-        context "when less than 10 seconds has elapsed since the last create request" do
-          before { Timecop.freeze(create_request_time + (submitted_success_lag.to_i - 8).seconds) }
-
-          it { expect(subject[:status]).to eq "submitted" }
-        end
-
-        context "when 10 seconds has elapsed since the last create request" do
-          before { Timecop.freeze(create_request_time + (submitted_success_lag.to_i + 8).seconds) }
-
-          it { expect(subject[:status]).to eq "success" }
-        end
-
-        context "when GOVPAY_REFUND_SUBMITTED_SUCCESS_LAG is not set" do
-          let(:submitted_success_lag) { nil }
-
-          before { Timecop.freeze(create_request_time + 1.hour) }
-
-          it { expect(subject[:status]).to eq "success" }
-        end
-      end
-    end
-  end
-end

data/spec/services/govpay_request_refund_service_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-module DefraRubyMocks
-
-  RSpec.describe GovpayRequestRefundService do
-    let(:payment_id) { SecureRandom.hex(26) }
-    let(:amount) { 2000 }
-    let(:refund_amount_available) { amount }
-
-    before { Helpers::Configuration.prep_for_tests }
-
-    # Note that the service currently supports only "submitted" responses.
-    describe ".run" do
-
-      subject { described_class.run(payment_id: payment_id, amount: amount, refund_amount_available: refund_amount_available).deep_symbolize_keys }
-
-      context "when the refund has been successfully submitted" do
-
-        it "returns a response with the expected status" do
-          expect(subject[:status]).to eq("submitted")
-        end
-
-        it "returns a response with the expected amount" do
-          expect(subject[:amount]).to eq(amount)
-        end
-      end
-    end
-  end
-end