firstclasspostcodes 0.0.1

data/spec/firstclasspostcodes/operations/get_postcode_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Firstclasspostcodes::Operations::GetPostcode do
+  class TestGetPostcode
+    attr_accessor :config
+
+    include Firstclasspostcodes::Operations::GetPostcode
+
+    def emit(event_name, properties); end
+
+    def request(params); end
+  end
+
+  subject { TestGetPostcode.new }
+
+  let(:operation_params) { { path: "/postcode", method: :get } }
+
+  let(:config) { double(geo_json?: false, debug?: true, logger: double(debug: nil)) }
+
+  before(:each) { allow(subject).to receive(:emit).with(anything, anything).and_return(true) }
+
+  before(:each) { subject.config = config }
+
+  specify { expect(subject).respond_to?(:get_postcode) }
+
+  describe "when the request is valid" do
+    before(:each) { allow(subject).to receive(:request).and_return(double) }
+
+    let(:postcode) { "test" }
+
+    it "returns the correct response" do
+      expect(subject).to receive(:request).with(operation_params.merge(
+                                                  query_params: {
+                                                    search: postcode,
+                                                  }
+                                                ))
+      response = subject.get_postcode(postcode)
+      expect(response).respond_to?(:list_addresses)
+      expect(response).respond_to?(:format_address)
+    end
+  end
+
+  describe "when the request is invalid" do
+    describe "when there are no parameters" do
+      it "raises an error" do
+        expect { subject.get_postcode(23_456) }.to raise_error(StandardError)
+      end
+    end
+
+    describe "when there is an empty string" do
+      it "raises an error" do
+        expect { subject.get_postcode("") }.to raise_error(StandardError)
+      end
+    end
+  end
+end

data/spec/firstclasspostcodes/operations/methods/format_address_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Firstclasspostcodes::Operations::Methods::FormatAddress do
+  class TestFormatAddress < Hash
+    include Firstclasspostcodes::Operations::Methods::FormatAddress
+  end
+
+  subject { TestFormatAddress[] }
+
+  let(:index) { "numbers:0" }
+
+  before(:each) do
+    subject.merge!(
+      numbers: [
+        {
+          number: 1,
+          street: "A Street",
+        },
+        {
+          number: "Flat A",
+          building: "Crescent",
+          street: "A Street",
+        },
+      ],
+      streets: [
+        "A Street",
+        "B Avenue",
+      ],
+      locality: "locality",
+      city: "city",
+      county: "county",
+      region: "region",
+      country: "country",
+      postcode: "postcode"
+    )
+  end
+
+  specify { expect(subject.respond_to?(:format_address)) }
+
+  describe "when the type is invalid" do
+    let(:index) { "dadwadada:0" }
+
+    it "throws an error" do
+      expect { subject.format_address(index) }.to raise_error(StandardError)
+    end
+  end
+
+  describe 'when the "postcode" type is passed in' do
+    let(:index) { "postcode:0" }
+
+    it "returns a formatted postcode" do
+      expect(subject.format_address(index)).to eq(
+        locality: "city",
+        region: "county",
+        postcode: "postcode",
+        country: "country"
+      )
+    end
+  end
+
+  describe 'when the "streets" type is passed in' do
+    let(:index) { "streets:1" }
+
+    it "returns a formatted street" do
+      expect(subject.format_address(index)).to eq(
+        address: "B Avenue",
+        locality: "city",
+        region: "county",
+        postcode: "postcode",
+        country: "country"
+      )
+    end
+
+    describe "when there are no streets" do
+      before(:each) { subject[:streets] = nil }
+
+      it "throws an error" do
+        expect { subject.format_address(index) }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe 'when the "numbers" type is passed in' do
+    let(:index) { "numbers:1" }
+
+    it "returns a formatted number" do
+      expect(subject.format_address(index)).to eq(
+        address: "Flat A, Crescent, A Street",
+        locality: "city",
+        region: "county",
+        postcode: "postcode",
+        country: "country"
+      )
+    end
+
+    describe "when there are no numbers" do
+      before(:each) { subject[:numbers] = nil }
+
+      it "throws an error" do
+        expect { subject.format_address(index) }.to raise_error(StandardError)
+      end
+    end
+  end
+end

data/spec/firstclasspostcodes/operations/methods/list_addresses_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Firstclasspostcodes::Operations::Methods::ListAddresses do
+  class TestListAddresses < Hash
+    include Firstclasspostcodes::Operations::Methods::ListAddresses
+  end
+
+  subject { TestListAddresses[] }
+
+  specify { expect(subject.respond_to?(:list_addresses)) }
+
+  describe "when there are no numbers or streets" do
+    before(:each) do
+      subject.merge!(
+        numbers: [],
+        streets: [],
+        locality: "locality",
+        city: "city",
+        postcode: "postcode"
+      )
+    end
+
+    it "returns a postcode option" do
+      expect(subject.list_addresses).to eq([
+        ["postcode:0", "city, postcode"],
+      ])
+    end
+  end
+
+  describe "when there are only streets" do
+    before(:each) do
+      subject.merge!(
+        numbers: [],
+        streets: ["A Street", "B Avenue"],
+        locality: "locality",
+        city: "city",
+        postcode: "postcode"
+      )
+    end
+
+    it "returns equal number of street options" do
+      expect(subject.list_addresses).to eq([
+        ["streets:0", "A Street, city, postcode"],
+        ["streets:1", "B Avenue, city, postcode"],
+      ])
+    end
+  end
+
+  describe "when there are streets and numbers" do
+    before(:each) do
+      subject.merge!(
+        numbers: [
+          {
+            number: 1,
+            street: "A Street",
+          },
+          {
+            number: "Flat A",
+            building: "Crescent",
+            street: "A Street",
+          },
+        ],
+        streets: ["A Street", "B Avenue"],
+        locality: "locality",
+        city: "city",
+        postcode: "postcode"
+      )
+    end
+
+    it "returns equal number of street options" do
+    end
+  end
+end

data/spec/firstclasspostcodes/response_error_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Firstclasspostcodes::ResponseError do
+  describe "when the error is a hash" do
+    let(:error_object) do
+      {
+        message: "message",
+        docUrl: "https://google.com/some-doc",
+        type: "type",
+      }
+    end
+
+    subject { Firstclasspostcodes::ResponseError.new(error_object) }
+
+    specify { expect(subject.message).to include error_object[:message] }
+
+    specify { expect(subject.type).to include error_object[:type] }
+
+    specify { expect(subject.message).to include error_object[:docUrl] }
+
+    specify { expect(subject.type).to eq error_object[:type] }
+
+    specify { expect(subject.doc_url).to eq error_object[:docUrl] }
+  end
+
+  describe "when the error is a message" do
+    let(:error_message) { "message" }
+
+    let(:error_type) { "type" }
+
+    subject { Firstclasspostcodes::ResponseError.new(error_message, error_type) }
+
+    specify { expect(subject.type).to eq(error_type) }
+
+    specify { expect(subject.message).to include error_message }
+
+    specify { expect(subject.message).to include error_type }
+
+    specify { expect(subject.doc_url).to include error_type }
+  end
+end

data/spec/firstclasspostcodes/version_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Firstclasspostcodes do
+  subject { Firstclasspostcodes::VERSION }
+
+  specify { expect(subject).to match(/^[0-9]+\.[0-9]+\.[0-9]+$/) }
+end

data/spec/firstclasspostcodes_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Firstclasspostcodes do
+  describe "#content" do
+    let(:config) { Firstclasspostcodes::Configuration.new }
+
+    it "defaults to json" do
+      expect(Firstclasspostcodes::Configuration.default.content).to eq("json")
+      expect(config.content).to eq("json")
+    end
+
+    # it 'raises when an invalid type is passed' do
+    #   expect { config.content = "awdgfde" }.to raise_error(StandardError)
+    # end
+  end
+
+  describe "#configure" do
+    it "calls a configuration block" do
+      expect { |b| Firstclasspostcodes.configure(&b) }.to yield_control
+    end
+  end
+
+  describe "#protocol" do
+    it "removes :// from the protocol" do
+      Firstclasspostcodes.configure { |c| c.protocol = "https://" }
+      expect(Firstclasspostcodes::Configuration.default.protocol).to eq("https")
+    end
+  end
+
+  describe "#host" do
+    it "removes http from host" do
+      Firstclasspostcodes.configure { |c| c.host = "http://example.com" }
+      expect(Firstclasspostcodes::Configuration.default.host).to eq("example.com")
+    end
+
+    it "removes https from host" do
+      Firstclasspostcodes.configure { |c| c.host = "https://wookiee.com" }
+      expect(Firstclasspostcodes::Configuration.default.host).to eq("wookiee.com")
+    end
+
+    it "removes trailing path from host" do
+      Firstclasspostcodes.configure { |c| c.host = "hobo.com/v4" }
+      expect(Firstclasspostcodes::Configuration.default.host).to eq("hobo.com")
+    end
+  end
+
+  describe "#base_path" do
+    it "prepends a slash to base_path" do
+      Firstclasspostcodes.configure { |c| c.base_path = "v4/dog" }
+      expect(Firstclasspostcodes::Configuration.default.base_path).to eq("/v4/dog")
+    end
+
+    it "doesn't prepend a slash if one is already there" do
+      Firstclasspostcodes.configure { |c| c.base_path = "/v4/dog" }
+      expect(Firstclasspostcodes::Configuration.default.base_path).to eq("/v4/dog")
+    end
+
+    it "ends up as a blank string if nil" do
+      Firstclasspostcodes.configure { |c| c.base_path = nil }
+      expect(Firstclasspostcodes::Configuration.default.base_path).to eq("")
+    end
+  end
+
+  describe "#geo_json?" do
+    let(:config) { Firstclasspostcodes::Configuration.new }
+
+    it "defaults to false" do
+      expect(Firstclasspostcodes::Configuration.default.geo_json?).to be_falsey
+      expect(config.geo_json?).to be_falsey
+    end
+
+    it "can be customized" do
+      config.content = "geo+json"
+      expect(config.geo_json?).to be_truthy
+    end
+  end
+
+  describe "#debug?" do
+    let(:config) { Firstclasspostcodes::Configuration.new }
+
+    it "defaults to false" do
+      expect(Firstclasspostcodes::Configuration.default.debug?).to be_falsey
+      expect(config.debug?).to be_falsey
+    end
+
+    it "can be customized" do
+      config.debug = true
+      expect(config.debug?).to be_truthy
+    end
+  end
+
+  describe "timeout in #build_request" do
+    let(:config) { Firstclasspostcodes::Configuration.new }
+
+    it "defaults to 0" do
+      expect(Firstclasspostcodes::Configuration.default.timeout).to eq(0)
+      expect(config.timeout).to eq(0)
+      expect(config.to_request_params[:timeout]).to eq(0)
+    end
+
+    it "can be customized" do
+      config.timeout = 100
+      expect(config.to_request_params[:timeout]).to eq(100)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "uri"
+require "simplecov"
+
+SimpleCov.start
+
+if ENV["CI"] == "true"
+  require "codecov"
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+# load the gem
+require "firstclasspostcodes"
+
+API_URL = ENV["API_URL"]
+
+API_KEY = ENV["API_KEY"]
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.before(:each) do
+    Typhoeus::Expectation.clear
+
+    uri = URI.parse(API_URL)
+
+    Firstclasspostcodes.configure do |c|
+      c.api_key = API_KEY
+      c.base_path = uri.path
+      c.protocol = uri.scheme
+      c.host = uri.host
+      c.host = "#{uri.host}:#{uri.port}" if uri.port
+    end
+  end
+end