defra_ruby_address 0.1.0

data/lib/defra_ruby/address/services/base_service.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "json"
+require "rest-client"
+
+module DefraRuby
+  module Address
+    class BaseService
+      def self.run(attrs = nil)
+        new.run(attrs)
+      end
+    end
+  end
+end

data/lib/defra_ruby/address/services/ea_address_facade_v1_1_service.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DefraRuby
+  module Address
+    class EaAddressFacadeV11Service < BaseService
+
+      PARAM_NAME = "query-string"
+
+      def run(postcode)
+        request = EaAddressFacadeRequest.new(PARAM_NAME)
+        request.execute(postcode)
+      end
+
+    end
+  end
+end

data/lib/defra_ruby/address/services/ea_address_facade_v1_service.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DefraRuby
+  module Address
+    class EaAddressFacadeV1Service < BaseService
+
+      PARAM_NAME = "postcode"
+
+      def run(postcode)
+        request = EaAddressFacadeRequest.new(PARAM_NAME)
+        request.execute(postcode)
+      end
+
+    end
+  end
+end

data/lib/defra_ruby/address/services/os_places_address_lookup_service.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module DefraRuby
+  module Address
+    class OsPlacesAddressLookupService < BaseService
+
+      def run(postcode)
+        @postcode = postcode
+        Response.new(response_exe)
+      end
+
+      private
+
+      OS_PLACES_ADDRESS_LOOKUP_NO_MATCH_ERROR_MSG = "Parameters are not valid"
+
+      attr_reader :postcode
+
+      def url
+        File.join(
+          DefraRuby::Address.configuration.host,
+          "/addresses?postcode=#{postcode}"
+        )
+      end
+
+      def response_exe
+        lambda do
+          begin
+            response = RestClient::Request.execute(
+              method: :get,
+              url: url,
+              timeout: DefraRuby::Address.configuration.timeout
+            )
+            JSON.parse(response)
+          rescue RestClient::BadRequest => e
+            raise process_error(e)
+          end
+        end
+      end
+
+      def process_error(error)
+        if JSON.parse(error.response)["error"]["message"] == OS_PLACES_ADDRESS_LOOKUP_NO_MATCH_ERROR_MSG
+          error = NoMatchError.new
+        end
+      rescue StandardError
+        error
+      ensure
+        error
+      end
+    end
+  end
+end

data/lib/defra_ruby/address/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module DefraRuby
+  module Address
+    VERSION = "0.1.0"
+  end
+end

data/spec/defra_ruby/address/configuration_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DefraRuby
+  module Address
+    RSpec.describe Configuration do
+      it "sets the appropriate default config settings" do
+        fresh_config = described_class.new
+
+        expect(fresh_config.timeout).to eq(3)
+        expect(fresh_config.host).to be_nil
+        expect(fresh_config.client_id).to eq(0)
+        expect(fresh_config.key).to eq("client1")
+      end
+    end
+  end
+end

data/spec/defra_ruby/address/response_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DefraRuby
+  module Address
+    RSpec.describe Response do
+      subject(:response) { described_class.new(response_exe) }
+
+      let(:successful) { -> { [{ "postcode" => "BS1 5AH" }] } }
+      let(:errored) { -> { raise "Boom!" } }
+
+      describe "#successful?" do
+        context "when the response throws an error" do
+          let(:response_exe) { errored }
+
+          it "returns false" do
+            expect(response).to_not be_successful
+          end
+        end
+
+        context "when the response doesn't throw an error" do
+          let(:response_exe) { successful }
+
+          it "returns true" do
+            expect(response).to be_successful
+          end
+        end
+      end
+
+      describe "#results" do
+        context "when the response throws an error" do
+          let(:response_exe) { errored }
+
+          it "returns an empty array" do
+            expect(response.results).to eq([])
+          end
+        end
+
+        context "when the response does not throw an error" do
+          let(:response_exe) { successful }
+
+          it "returns a JSON array" do
+            expect(response.results).to be_instance_of(Array)
+            expect(response.results[0]).to be_instance_of(Hash)
+            expect(response.results[0]["postcode"]).to eq("BS1 5AH")
+          end
+        end
+      end
+
+      describe "#error" do
+        context "when the response throws an error" do
+          let(:response_exe) { errored }
+
+          it "returns the error" do
+            expect(response.error).to be_a(StandardError)
+          end
+        end
+
+        context "when the response don't throw an error" do
+          let(:response_exe) { successful }
+
+          it "returns a nil object" do
+            expect(response.error).to be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/defra_ruby/address/services/ea_address_facade_v1_1_service_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DefraRuby
+  module Address
+    RSpec.describe EaAddressFacadeV11Service do
+      describe "#run" do
+        before do
+          DefraRuby::Address.configure { |c| c.host = "http://localhost:8005/" }
+          stub_request(:get, url).to_return(status: code, body: body)
+        end
+
+        let(:client_id) { DefraRuby::Address.configuration.client_id }
+        let(:key) { DefraRuby::Address.configuration.key }
+        let(:postcode) { "BS1 5AH" }
+        let(:url) { "http://localhost:8005/address-service/v1/addresses/postcode?client-id=#{client_id}&key=#{key}&query-string=#{postcode}" }
+        let(:code) { 200 }
+        let(:body) { File.read("spec/fixtures/ea_address_facade_v1_1_valid.json") }
+
+        include_examples "handle request errors"
+
+        context "when the postcode is valid" do
+
+          it "returns a successful response" do
+            response = described_class.run(postcode)
+
+            expect(a_request(:get, url)).to have_been_made.at_most_once
+
+            expect(response).to be_a(Response)
+            expect(response.successful?).to eq(true)
+            expect(response.results).not_to be_empty
+          end
+        end
+
+        context "when the postcode is invalid" do
+          context "because it is not found" do
+            let(:postcode) { "BS1 9XX" }
+            let(:body) { File.read("spec/fixtures/ea_address_facade_v1_1_not_found.json") }
+
+            it "returns a 'NoMatchError'" do
+              response = described_class.run(postcode)
+
+              expect(a_request(:get, url)).to have_been_made.at_most_once
+
+              expect(response).to be_a(Response)
+              expect(response).to_not be_successful
+              expect(response.results).to be_empty
+              expect(response.error).to be_an_instance_of(DefraRuby::Address::NoMatchError)
+            end
+          end
+
+          context "because it is blank" do
+            let(:postcode) { "" }
+            let(:code) { 400 }
+            let(:body) { File.read("spec/fixtures/ea_address_facade_v1_1_blank.json") }
+
+            it "returns a failed response" do
+              response = described_class.run(postcode)
+
+              expect(a_request(:get, url)).to have_been_made.at_most_once
+
+              expect(response).to be_a(Response)
+              expect(response).to_not be_successful
+              expect(response.results).to be_empty
+              expect(response.error).to be_an_instance_of(RestClient::BadRequest)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/defra_ruby/address/services/ea_address_facade_v1_service_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DefraRuby
+  module Address
+    RSpec.describe EaAddressFacadeV1Service do
+      describe "#run" do
+        before do
+          DefraRuby::Address.configure { |c| c.host = "http://localhost:8005/" }
+          stub_request(:get, url).to_return(status: code, body: body)
+        end
+
+        let(:client_id) { DefraRuby::Address.configuration.client_id }
+        let(:key) { DefraRuby::Address.configuration.key }
+        let(:postcode) { "BS1 5AH" }
+        let(:url) { "http://localhost:8005/address-service/v1/addresses/postcode?client-id=#{client_id}&key=#{key}&postcode=#{postcode}" }
+        let(:code) { 200 }
+        let(:body) { File.read("spec/fixtures/ea_address_facade_v1_valid.json") }
+
+        include_examples "handle request errors"
+
+        context "when the postcode is valid" do
+
+          it "returns a successful response" do
+            response = described_class.run(postcode)
+
+            expect(a_request(:get, url)).to have_been_made.at_most_once
+
+            expect(response).to be_a(Response)
+            expect(response.successful?).to eq(true)
+            expect(response.results).not_to be_empty
+          end
+        end
+
+        context "when the postcode is invalid" do
+          context "because it is not found" do
+            let(:postcode) { "BS1 9XX" }
+            let(:body) { File.read("spec/fixtures/ea_address_facade_v1_not_found.json") }
+
+            it "returns a 'NoMatchError'" do
+              response = described_class.run(postcode)
+
+              expect(a_request(:get, url)).to have_been_made.at_most_once
+
+              expect(response).to be_a(Response)
+              expect(response).to_not be_successful
+              expect(response.results).to be_empty
+              expect(response.error).to be_an_instance_of(DefraRuby::Address::NoMatchError)
+            end
+          end
+
+          context "because it is blank" do
+            let(:postcode) { "" }
+            let(:code) { 400 }
+            let(:body) { File.read("spec/fixtures/ea_address_facade_v1_blank.json") }
+
+            it "returns a failed response" do
+              response = described_class.run(postcode)
+
+              expect(a_request(:get, url)).to have_been_made.at_most_once
+
+              expect(response).to be_a(Response)
+              expect(response).to_not be_successful
+              expect(response.results).to be_empty
+              expect(response.error).to be_an_instance_of(RestClient::BadRequest)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/defra_ruby/address/services/os_places_address_lookup_service_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DefraRuby
+  module Address
+    RSpec.describe OsPlacesAddressLookupService do
+      describe "#run" do
+        before do
+          DefraRuby::Address.configure { |c| c.host = "http://localhost:8005/" }
+          stub_request(:get, url).to_return(status: code, body: body)
+        end
+
+        let(:postcode) { "BS1 5AH" }
+        let(:url) { "http://localhost:8005/addresses?postcode=#{postcode}" }
+        let(:code) { 200 }
+        let(:body) { File.read("spec/fixtures/os_places_address_lookup_valid.json") }
+
+        include_examples "handle request errors"
+
+        context "when the postcode is valid" do
+
+          it "returns a successful response" do
+            response = described_class.run(postcode)
+
+            expect(a_request(:get, url)).to have_been_made.at_most_once
+
+            expect(response).to be_a(Response)
+            expect(response.successful?).to eq(true)
+            expect(response.results).not_to be_empty
+          end
+        end
+
+        context "when the postcode is invalid" do
+          let(:code) { 400 }
+
+          context "because it is not found" do
+            let(:postcode) { "BS1 9XX" }
+            let(:body) { File.read("spec/fixtures/os_places_address_lookup_not_found.json") }
+
+            it "returns a 'NoMatchError'" do
+              response = described_class.run(postcode)
+
+              expect(a_request(:get, url)).to have_been_made.at_most_once
+
+              expect(response).to be_a(Response)
+              expect(response).to_not be_successful
+              expect(response.results).to be_empty
+              expect(response.error).to be_an_instance_of(DefraRuby::Address::NoMatchError)
+            end
+          end
+
+          context "because it is blank" do
+            let(:postcode) { "" }
+            let(:body) { File.read("spec/fixtures/os_places_address_lookup_blank.json") }
+
+            it "returns a failed response" do
+              response = described_class.run(postcode)
+
+              expect(a_request(:get, url)).to have_been_made.at_most_once
+
+              expect(response).to be_a(Response)
+              expect(response).to_not be_successful
+              expect(response.results).to be_empty
+              expect(response.error).to be_an_instance_of(RestClient::BadRequest)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/defra_ruby/address_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe DefraRuby::Address do
+  describe "VERSION" do
+    it "is a version string in the correct format" do
+      expect(DefraRuby::Address::VERSION).to be_a(String)
+      expect(DefraRuby::Address::VERSION).to match(/\d+\.\d+\.\d+/)
+    end
+  end
+
+  describe "#configuration" do
+    context "when the host app has not provided configuration" do
+      it "returns a DefraRuby::Address::Configuration instance" do
+        expect(described_class.configuration).to be_an_instance_of(DefraRuby::Address::Configuration)
+      end
+    end
+
+    context "when the host app has provided configuration" do
+      let(:host) { "http://localhost:9012" }
+
+      it "returns an DefraRuby::Address::Configuration instance with a matching host" do
+        described_class.configure { |config| config.host = host }
+
+        expect(described_class.configuration.host).to eq(host)
+      end
+    end
+  end
+end