creditsafe 0.5.0 → 0.5.1

data/lib/creditsafe/request/find_company.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'creditsafe/namespace'
-require 'creditsafe/match_type'
+require "creditsafe/match_type"
+require "creditsafe/namespace"
 
 module Creditsafe
   module Request
@@ -20,23 +20,29 @@ module Creditsafe
       def message
         search_criteria = {}
 
-        search_criteria["#{Creditsafe::Namespace::DAT}:Name"] = {
-          '@MatchType' => match_type,
-          :content! => company_name
-        } unless company_name.nil?
+        unless company_name.nil?
+          search_criteria["#{Creditsafe::Namespace::DAT}:Name"] = {
+            "@MatchType" => match_type,
+            :content! => company_name,
+          }
+        end
 
         unless registration_number.nil?
           search_criteria["#{Creditsafe::Namespace::DAT}:RegistrationNumber"] =
             registration_number
         end
 
-        search_criteria["#{Creditsafe::Namespace::DAT}:Address"] = {
-          "#{Creditsafe::Namespace::DAT}:City" => city
-        } unless city.nil?
+        unless city.nil?
+          search_criteria["#{Creditsafe::Namespace::DAT}:Address"] = {
+            "#{Creditsafe::Namespace::DAT}:City" => city,
+          }
+        end
 
-        search_criteria["#{Creditsafe::Namespace::DAT}:Address"] = {
-          "#{Creditsafe::Namespace::DAT}:PostalCode" => postal_code
-        } unless postal_code.nil?
+        unless postal_code.nil?
+          search_criteria["#{Creditsafe::Namespace::DAT}:Address"] = {
+            "#{Creditsafe::Namespace::DAT}:PostalCode" => postal_code,
+          }
+        end
 
         build_message(search_criteria)
       end
@@ -55,13 +61,14 @@ module Creditsafe
       def build_message(search_criteria)
         {
           "#{Creditsafe::Namespace::OPER}:countries" => {
-            "#{Creditsafe::Namespace::CRED}:CountryCode" => country_code
+            "#{Creditsafe::Namespace::CRED}:CountryCode" => country_code,
           },
-          "#{Creditsafe::Namespace::OPER}:searchCriteria" => search_criteria
+          "#{Creditsafe::Namespace::OPER}:searchCriteria" => search_criteria,
         }
       end
 
       # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
       def check_search_criteria(search_criteria)
         if search_criteria[:country_code].nil?
           raise ArgumentError, "country_code is a required search criteria"
@@ -72,14 +79,15 @@ module Creditsafe
                                "required search criteria"
         end
 
-        if search_criteria[:city] && search_criteria[:country_code] != 'DE'
+        if search_criteria[:city] && search_criteria[:country_code] != "DE"
           raise ArgumentError, "city is only supported for German searches"
         end
 
-        if search_criteria[:postal_code] && search_criteria[:country_code] != 'DE'
+        if search_criteria[:postal_code] && search_criteria[:country_code] != "DE"
           raise ArgumentError, "Postal code is only supported for German searches"
         end
       end
+      # rubocop:enable Metrics/MethodLength
       # rubocop:enable Metrics/CyclomaticComplexity
 
       def only_registration_number_or_company_name_provided?(search_criteria)

data/lib/creditsafe/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Creditsafe
-  VERSION = '0.5.0'
+  VERSION = "0.5.1"
 end

data/lib/creditsafe.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
-require 'creditsafe/errors'
-require 'creditsafe/client'
+
+require "creditsafe/errors"
+require "creditsafe/client"

data/spec/creditsafe/client_spec.rb

@@ -1,50 +1,60 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'creditsafe/client'
-require 'timecop'
 
-URL = 'https://webservices.creditsafe.com/GlobalData/1.3/'\
-      'MainServiceBasic.svc'
+require "spec_helper"
+require "creditsafe/client"
+require "timecop"
+
+URL = "https://webservices.creditsafe.com/GlobalData/1.3/"\
+      "MainServiceBasic.svc"
 
 RSpec.describe(Creditsafe::Client) do
   notifications = []
   let(:username) { "AzureDiamond" }
   let(:password) { "hunter2" }
+
+  # rubocop:disable RSpec/BeforeAfterAll
   before(:all) do
     ActiveSupport::Notifications.subscribe do |*args|
       notifications << ActiveSupport::Notifications::Event.new(*args)
     end
   end
-  before(:each) { notifications = [] }
+  # rubocop:enable RSpec/BeforeAfterAll
 
-  shared_examples_for 'sends notifications' do
+  before { notifications = [] }
+
+  shared_examples_for "sends notifications" do
     let(:time) { Time.local(1990) }
-    it 'records a SOAP event' do
-      Timecop.freeze(time) do
-        method_call
-      end
-      expect(notifications).to match([have_attributes(
-        name: "creditsafe.#{soap_verb}",
-        transaction_id: match(/\A.{20}\Z/),
-        time: time,
-        end: time,
-        payload: {
-          request: be_truthy,
-          response: be_truthy
-        }
-      )])
+
+    it "records a SOAP event" do
+      Timecop.freeze(time) { method_call }
+
+      expect(notifications).to match(
+        [
+          have_attributes(
+            name: "creditsafe.#{soap_verb}",
+            transaction_id: match(/\A.{20}\Z/),
+            time: time,
+            end: time,
+            payload: {
+              request: be_truthy,
+              response: be_truthy,
+            },
+          ),
+        ],
+      )
     end
   end
-  shared_examples_for 'handles api errors' do
-    context 'when an error occurs due to invalid credentials' do
+
+  shared_examples_for "handles api errors" do
+    context "when an error occurs due to invalid credentials" do
       before do
         stub_request(:post, URL).to_return(
-          body: load_fixture('error-invalid-credentials.html'),
-          status: 401
+          body: load_fixture("error-invalid-credentials.html"),
+          status: 401,
         )
       end
 
-      it 'raises an AccountError' do
+      it "raises an AccountError" do
         expect { method_call }.to raise_error(
           Creditsafe::AccountError, /invalid credentials/
         ) do |error|
@@ -54,49 +64,46 @@ RSpec.describe(Creditsafe::Client) do
                 name: "creditsafe.#{soap_verb}",
                 payload: {
                   request: be_truthy,
-                  error: error
-                }
-              )
-            ]
+                  error: error,
+                },
+              ),
+            ],
           )
         end
       end
     end
 
-    context 'when an error occurs due to a fault' do
+    context "when an error occurs due to a fault" do
       before do
         stub_request(:post, URL).
-          to_return(body: load_fixture('error-fault.xml'))
+          to_return(body: load_fixture("error-fault.xml"))
       end
 
-      it 'raises an UnknownApiError' do
-        expect { method_call }.to raise_error(
-          Creditsafe::UnknownApiError
-        ) do |error|
+      it "raises an UnknownApiError" do
+        expect { method_call }.to raise_error(Creditsafe::UnknownApiError) do |error|
           expect(notifications).to match(
             [
               have_attributes(
                 name: "creditsafe.#{soap_verb}",
                 payload: {
                   request: be_truthy,
-                  error: error
-                }
-              )
-            ]
+                  error: error,
+                },
+              ),
+            ],
           )
         end
       end
     end
 
-    context 'when a HTTP error occurs' do
+    context "when a HTTP error occurs" do
       before do
         stub_request(:post, URL).to_timeout
       end
 
-      it 'raises an HttpError' do
-        expect { method_call }.to(
-          raise_error(Creditsafe::HttpError, /Excon::Error(?:s)?::Timeout/)
-        )
+      it "raises an HttpError" do
+        expect { method_call }.
+          to raise_error(Creditsafe::HttpError, /Excon::Error(?:s)?::Timeout/)
       end
     end
   end
@@ -110,19 +117,23 @@ RSpec.describe(Creditsafe::Client) do
 
     context "without a username" do
       let(:username) { nil }
+
       it { is_expected.to raise_error(ArgumentError) }
     end
   end
 
   describe "#inspect" do
-    let(:client) { described_class.new(username: username, password: password) }
     subject { client.inspect }
 
+    let(:client) { described_class.new(username: username, password: password) }
+
     it { is_expected.to_not include(password) }
   end
 
-  describe '#find_company' do
-    let(:soap_verb) { 'find_companies' }
+  describe "#find_company" do
+    subject { -> { method_call } }
+
+    let(:soap_verb) { "find_companies" }
     let(:client) { described_class.new(username: username, password: password) }
     let(:country_code) { "GB" }
     let(:registration_number) { "RN123" }
@@ -133,49 +144,54 @@ RSpec.describe(Creditsafe::Client) do
         country_code: country_code,
         registration_number: registration_number,
         city: city,
-        postal_code: postal_code
+        postal_code: postal_code,
       }.reject { |_, v| v.nil? }
     end
 
-    subject(:find_company) { client.find_company(search_criteria) }
-    subject(:method_call) { find_company }
+    let(:find_company) { client.find_company(search_criteria) }
+    let(:method_call) { find_company }
 
     before do
       stub_request(:post, URL).to_return(
-        body: load_fixture('find-companies-successful.xml'),
-        status: 200
+        body: load_fixture("find-companies-successful.xml"),
+        status: 200,
       )
     end
 
-    subject { -> { method_call } }
     it { is_expected.to_not raise_error }
 
     context "without a country_code" do
       let(:country_code) { nil }
+
       it { is_expected.to raise_error(ArgumentError) }
     end
 
     context "without a registration_number" do
       let(:registration_number) { nil }
+
       it { is_expected.to raise_error(ArgumentError) }
     end
 
     context "with a city" do
       let(:city) { "Berlin" }
+
       it { is_expected.to raise_error(ArgumentError) }
 
       context "in Germany" do
         let(:country_code) { "DE" }
+
         it { is_expected.to_not raise_error }
       end
     end
 
     context "with a postal_code" do
       let(:postal_code) { "41199" }
+
       it { is_expected.to raise_error(ArgumentError) }
 
       context "in Germany" do
         let(:country_code) { "DE" }
+
         it { is_expected.to_not raise_error }
       end
     end
@@ -198,44 +214,44 @@ RSpec.describe(Creditsafe::Client) do
       end
     end
 
-    it 'requests the company deatils' do
+    it "requests the company deatils" do
       find_company
       expect(a_request(:post, URL).with do |req|
                expect(CompareXML.equivalent?(
                         Nokogiri::XML(req.body),
-                        load_xml_fixture('find-companies-request.xml'),
-                        verbose: true
+                        load_xml_fixture("find-companies-request.xml"),
+                        verbose: true,
                )).to eq([])
              end).to have_been_made
     end
 
-    it 'returns the company details' do
+    it "returns the company details" do
       expect(find_company).
-        to eq(:name => 'GOCARDLESS LTD',
-              :type => 'Ltd',
-              :status => 'Active',
-              :registration_number => '07495895',
+        to eq(:name => "GOCARDLESS LTD",
+              :type => "Ltd",
+              :status => "Active",
+              :registration_number => "07495895",
               :address => {
-                simple_value: '338-346, GOSWELL, LONDON',
-                postal_code: 'EC1V7LQ'
+                simple_value: "338-346, GOSWELL, LONDON",
+                postal_code: "EC1V7LQ",
               },
-              :available_report_types => { available_report_type: 'Full' },
-              :available_languages => { available_language: 'EN' },
-              :@date_of_latest_accounts => '2014-01-31T00:00:00Z',
-              :@online_reports => 'true',
-              :@monitoring => 'false',
-              :@country => 'GB',
-              :@id => 'GB003/0/07495895')
+              :available_report_types => { available_report_type: "Full" },
+              :available_languages => { available_language: "EN" },
+              :@date_of_latest_accounts => "2014-01-31T00:00:00Z",
+              :@online_reports => "true",
+              :@monitoring => "false",
+              :@country => "GB",
+              :@id => "GB003/0/07495895")
     end
 
-    include_examples 'sends notifications'
-    include_examples 'handles api errors'
+    include_examples "sends notifications"
+    include_examples "handles api errors"
 
     context "when no companies are found" do
       before do
         stub_request(:post, URL).to_return(
-          body: load_fixture('find-companies-none-found.xml'),
-          status: 200
+          body: load_fixture("find-companies-none-found.xml"),
+          status: 200,
         )
       end
 
@@ -253,14 +269,14 @@ RSpec.describe(Creditsafe::Client) do
                 find_companies_result: include(
                   messages: {
                     message: include(
-                      "There are no results matching specified criteria."
-                    )
+                      "There are no results matching specified criteria.",
+                    ),
                   },
-                  companies: be_nil
-                )
-              )
-            }
-          }
+                  companies: be_nil,
+                ),
+              ),
+            },
+          },
         )])
       end
     end
@@ -268,80 +284,85 @@ RSpec.describe(Creditsafe::Client) do
     context "when an error occurs with further details" do
       before do
         stub_request(:post, URL).to_return(
-          body: load_fixture('find-companies-error.xml'),
-          status: 200
+          body: load_fixture("find-companies-error.xml"),
+          status: 200,
         )
       end
 
-      it 'gives a useful error, with the specific error in the response' do
+      it "gives a useful error, with the specific error in the response" do
         expect { method_call }.to raise_error(
           Creditsafe::RequestError,
-          'Invalid operation parameters (Invalid countries list specified.)'
+          "Invalid operation parameters (Invalid countries list specified.)",
         )
       end
 
       context "with further details provided in the response" do
         before do
           stub_request(:post, URL).to_return(
-            body: load_fixture('find-companies-error-no-text.xml'),
-            status: 200
+            body: load_fixture("find-companies-error-no-text.xml"),
+            status: 200,
           )
         end
 
-        it 'gives a useful error, with the specific error in the response' do
+        it "gives a useful error, with the specific error in the response" do
           expect { method_call }.to raise_error(
             Creditsafe::RequestError,
-            'Invalid operation parameters'
+            "Invalid operation parameters",
           )
         end
       end
     end
   end
 
-  describe '#company_report' do
-    let(:soap_verb) { 'retrieve_company_online_report' }
+  describe "#company_report" do
     before do
       stub_request(:post, URL).to_return(
-        body: load_fixture('company-report-successful.xml'),
-        status: 200
+        body: load_fixture("company-report-successful.xml"),
+        status: 200,
       )
     end
+
+    let(:soap_verb) { "retrieve_company_online_report" }
     let(:client) { described_class.new(username: username, password: password) }
     let(:custom_data) { { foo: "bar", bar: "baz" } }
-    subject(:company_report) do
-      client.company_report('GB003/0/07495895', custom_data: custom_data)
+    let(:company_report) do
+      client.company_report("GB003/0/07495895", custom_data: custom_data)
     end
-    subject(:method_call) { company_report }
+    let(:method_call) { company_report }
 
-    it 'requests the company details' do
+    it "requests the company details" do
       company_report
-      expect(a_request(:post, URL).with do |req|
-               expect(CompareXML.equivalent?(
-                        Nokogiri::XML(req.body),
-                        load_xml_fixture('company-report-request.xml'),
-                        verbose: true
-               )).to eq([])
-             end).to have_been_made
+      request = a_request(:post, URL).with do |req|
+        expect(
+          CompareXML.equivalent?(
+            Nokogiri::XML(req.body),
+            load_xml_fixture("company-report-request.xml"),
+            verbose: true,
+          ),
+        ).to eq([])
+      end
+
+      expect(request).to have_been_made
     end
 
-    it 'returns the company details' do
+    it "returns the company details" do
       expect(company_report).to include(:company_summary)
     end
 
-    include_examples 'sends notifications'
-    include_examples 'handles api errors'
+    include_examples "sends notifications"
+    include_examples "handles api errors"
 
-    context 'when a report is unavailable' do
+    context "when a report is unavailable" do
       before do
         stub_request(:post, URL).
-          to_return(body: load_fixture('company-report-not-found.xml'))
+          to_return(body: load_fixture("company-report-not-found.xml"))
       end
 
-      it 'raises an error' do
+      it "raises an error" do
         expect { company_report }.to raise_error(Creditsafe::DataError)
       end
 
-      it 'gives a useful error message' do
+      it "gives a useful error message" do
         expect { company_report }.to raise_error(
           Creditsafe::DataError, /Report unavailable/
         )

data/spec/creditsafe/messages_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'creditsafe/messages'
+
+require "spec_helper"
+require "creditsafe/messages"
 
 RSpec.describe(Creditsafe::Messages) do
   describe ".for_code" do
@@ -8,27 +9,31 @@ RSpec.describe(Creditsafe::Messages) do
 
     context "for a valid code" do
       let(:code) { "020101" }
+
       its(:code) { is_expected.to eq(code) }
-      its(:message) { is_expected.to eq('Invalid credentials') }
+      its(:message) { is_expected.to eq("Invalid credentials") }
       its(:error_class) { is_expected.to eq(Creditsafe::AccountError) }
     end
 
     context "for a code without leading zero" do
       let(:code) { "20101" }
+
       its(:code) { is_expected.to eq("0#{code}") }
-      its(:message) { is_expected.to eq('Invalid credentials') }
+      its(:message) { is_expected.to eq("Invalid credentials") }
       its(:error_class) { is_expected.to eq(Creditsafe::AccountError) }
     end
 
     context "for an unknown code" do
       let(:code) { "999999" }
+
       its(:code) { is_expected.to eq(code) }
-      its(:message) { is_expected.to eq('Unknown error') }
+      its(:message) { is_expected.to eq("Unknown error") }
       its(:error_class) { is_expected.to eq(Creditsafe::UnknownApiError) }
     end
 
     context "for an empty code" do
-      let(:code) { '' }
+      let(:code) { "" }
+
       it "was passed the wrong parameters" do
         expect { subject(:message) }.to raise_error(ArgumentError)
       end
@@ -36,9 +41,8 @@ RSpec.describe(Creditsafe::Messages) do
   end
 
   describe(Creditsafe::Messages::Message) do
-    subject(:message) do
-      described_class.new(code: code, message: text, error: error)
-    end
+    subject(:message) { described_class.new(code: code, message: text, error: error) }
+
     let(:text) { "Error message" }
     let(:code) { "020101" }
     let(:error) { true }
@@ -48,6 +52,7 @@ RSpec.describe(Creditsafe::Messages) do
 
       context "when there is no error" do
         let(:error) { false }
+
         it { is_expected.to be_nil }
       end
 
@@ -56,11 +61,13 @@ RSpec.describe(Creditsafe::Messages) do
 
         context "for a processing error code" do
           let(:code) { "040102" }
+
           it { is_expected.to eq(Creditsafe::ProcessingError) }
         end
 
         context "for an unknown error code" do
           let(:code) { "060102" }
+
           it { is_expected.to eq(Creditsafe::UnknownApiError) }
         end
       end

data/spec/spec_helper.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
-require 'webmock/rspec'
-require 'nokogiri'
-require 'rspec/its'
-require 'compare-xml'
+
+require "webmock/rspec"
+require "nokogiri"
+require "rspec/its"
+require "compare-xml"
 
 def load_fixture(name)
-  File.read(File.join(File.dirname(__FILE__), 'fixtures', name))
+  File.read(File.join(File.dirname(__FILE__), "fixtures", name))
 end
 
 def load_xml_fixture(name)
-  Nokogiri::XML(File.open(File.join(File.dirname(__FILE__), 'fixtures', name)))
+  Nokogiri::XML(File.open(File.join(File.dirname(__FILE__), "fixtures", name)))
 end