ideal_postcodes 2.0.0 → 2.0.1

data/spec/idealpostcodes_spec.rb

@@ -1,56 +1,56 @@
 require 'spec_helper'
 
 describe IdealPostcodes do
-	describe '#request' do
-		it 'generates a HTTP request' do
-			response = IdealPostcodes.request :get, 'postcodes/ID1 1QD'
-			expect(response[:code]).to eq(2000)
-		end
-		it 'raises an error if no key is provided' do
-			IdealPostcodes.api_key = nil
-			expect do
-				response = IdealPostcodes.request :get, 'postcodes/ID1 1QD'
-			end.to raise_error(IdealPostcodes::AuthenticationError)
-		end
-		it 'raises authentication error if invalid key is provided' do
-			IdealPostcodes.api_key = 'foo'
-			expect do
-				response = IdealPostcodes.request :get, 'postcodes/ID1 1QD'
-			end.to raise_error(IdealPostcodes::AuthenticationError)
-		end
-		it 'raises token exhausted error if key balance is depleted' do
-			expect do
-				response = IdealPostcodes.request :get, 'postcodes/ID1 CLIP'
-			end.to raise_error(IdealPostcodes::TokenExhaustedError)
-		end
-		it 'raises limit reached error if a limit has been breached' do
-			expect do
-				response = IdealPostcodes.request :get, 'postcodes/ID1 CHOP'
-			end.to raise_error(IdealPostcodes::LimitReachedError)
-		end
-	end
+  describe '#request' do
+    it 'generates a HTTP request' do
+      response = IdealPostcodes.request :get, 'postcodes/ID1 1QD'
+      expect(response[:code]).to eq(2000)
+    end
+    it 'raises an error if no key is provided' do
+      IdealPostcodes.api_key = nil
+      expect do
+        response = IdealPostcodes.request :get, 'postcodes/ID1 1QD'
+      end.to raise_error(IdealPostcodes::AuthenticationError)
+    end
+    it 'raises authentication error if invalid key is provided' do
+      IdealPostcodes.api_key = 'foo'
+      expect do
+        response = IdealPostcodes.request :get, 'postcodes/ID1 1QD'
+      end.to raise_error(IdealPostcodes::AuthenticationError)
+    end
+    it 'raises token exhausted error if key balance is depleted' do
+      expect do
+        response = IdealPostcodes.request :get, 'postcodes/ID1 CLIP'
+      end.to raise_error(IdealPostcodes::TokenExhaustedError)
+    end
+    it 'raises limit reached error if a limit has been breached' do
+      expect do
+        response = IdealPostcodes.request :get, 'postcodes/ID1 CHOP'
+      end.to raise_error(IdealPostcodes::LimitReachedError)
+    end
+  end
 
-	describe '.key_available' do
-		it 'returns true if key is available' do
-			IdealPostcodes.api_key = "iddqd"
-			expect(IdealPostcodes.key_available).to equal(true)
-		end
-		it 'returns false if key is unavailable' do
-			IdealPostcodes.api_key = "idkfa"
-			expect(IdealPostcodes.key_available).to equal(false)
-		end
-	end
+  describe '.key_available' do
+    it 'returns true if key is available' do
+      IdealPostcodes.api_key = 'iddqd'
+      expect(IdealPostcodes.key_available).to equal(true)
+    end
+    it 'returns false if key is unavailable' do
+      IdealPostcodes.api_key = 'idkfa'
+      expect(IdealPostcodes.key_available).to equal(false)
+    end
+  end
 
-	describe '.key_details' do
-		it 'raises an exception if no secret is provided' do
-			expect {
-				IdealPostcodes.key_details
-			}.to raise_error(IdealPostcodes::AuthenticationError)
-		end
-		it 'returns key information' do
-			IdealPostcodes.apply_secret(secret_key)
-			response = IdealPostcodes.key_details
-			expect(is_key(response)).to eq(true)
-		end
-	end
-end
+  describe '.key_details' do
+    it 'raises an exception if no secret is provided' do
+      expect { IdealPostcodes.key_details }.to raise_error(
+        IdealPostcodes::AuthenticationError
+      )
+    end
+    it 'returns key information' do
+      IdealPostcodes.apply_secret(secret_key)
+      response = IdealPostcodes.key_details
+      expect(is_key(response)).to eq(true)
+    end
+  end
+end

data/spec/keys_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
 describe IdealPostcodes::Key do
-	describe '.lookup' do
-		it 'returns the availability status of a key (true key)' do
-			result = IdealPostcodes::Key.lookup "iddqd"
-			expect(result[:available]).to eq(true)
-		end
-		it 'returns the availability status of a key (false key)' do
-			result = IdealPostcodes::Key.lookup "idkfa"
-			expect(result[:available]).to eq(false)
-		end
-	end	
+  describe '.lookup' do
+    it 'returns the availability status of a key (true key)' do
+      result = IdealPostcodes::Key.lookup 'iddqd'
+      expect(result[:available]).to eq(true)
+    end
+    it 'returns the availability status of a key (false key)' do
+      result = IdealPostcodes::Key.lookup 'idkfa'
+      expect(result[:available]).to eq(false)
+    end
+  end
 
-	describe '.lookup_details' do
-		it 'returns key details' do
-			result = IdealPostcodes::Key.lookup_details "gandhi", secret_key
-			expect(result[:lookups_remaining]).to_not be_nil
-			expect(result[:daily_limit]).to_not be_nil
-			expect(result[:individual_limit]).to_not be_nil
-			expect(result[:allowed_urls]).to_not be_nil
-			expect(result[:notifications]).to_not be_nil
-		end
-	end
-end
+  describe '.lookup_details' do
+    it 'returns key details' do
+      result = IdealPostcodes::Key.lookup_details 'gandhi', secret_key
+      expect(result[:lookups_remaining]).to_not be_nil
+      expect(result[:daily_limit]).to_not be_nil
+      expect(result[:individual_limit]).to_not be_nil
+      expect(result[:allowed_urls]).to_not be_nil
+      expect(result[:notifications]).to_not be_nil
+    end
+  end
+end

data/spec/postcodes_spec.rb

@@ -1,66 +1,77 @@
 require 'spec_helper'
 
 describe IdealPostcodes::Postcode do
-	describe '.lookup' do
-		it 'returns a list of addresses for a postcode' do
-			addresses = IdealPostcodes::Postcode.lookup 'ID1 1QD'
-			expect(addresses.length).to be > 0
-			addresses.each do |address|
-				expect(is_address(address)).to eq(true)
-				expect(address[:postcode]).to eq('ID1 1QD')
-			end
-		end
-		it 'returns an empty array if postcode does not exist' do
-			addresses = IdealPostcodes::Postcode.lookup 'ID1 KFA'
-			expect(addresses.length).to eq(0)
-		end
-		it 'raises an exception if key has run out of balance' do
-			expect {
-				IdealPostcodes::Postcode.lookup 'ID1 CLIP'
-			}.to raise_error(IdealPostcodes::TokenExhaustedError)
-		end
-		it 'raises an exception if limit has been reached' do
-			expect {
-				IdealPostcodes::Postcode.lookup 'ID1 CHOP'
-			}.to raise_error(IdealPostcodes::LimitReachedError)
-		end
-		it 'raises an exception if invalid key' do
-			IdealPostcodes.api_key = 'foo'
-			expect {
-				IdealPostcodes::Postcode.lookup 'ID1 1QD'
-			}.to raise_error(IdealPostcodes::AuthenticationError)
-		end
-	end
-	describe '.find_by_location' do
-		it 'returns an array of postcodes and locations' do
-			lon = 0.6298
-			lat = 51.7923
-			postcodes = IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat
-			expect(postcodes.length).to be > 0
-			postcodes.each do |postcode|
-				expect(is_postcode_location(postcode)).to eq(true)
-			end
-		end
-		it 'returns an empty array if no results are found' do
-			lon = 0
-			lat = 0
-			postcodes = IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat
-			expect(postcodes).to be_a(Array)
-			expect(postcodes.length).to eq(0)
-		end
-		it 'is sensitive to limit parameter' do
-			lon = 0.6298
-			lat = 51.7923
-			limit = 1
-			postcodes = IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat, limit: limit
-			expect(postcodes.length).to eq(limit)
-		end
-		it 'is sensitive to radius parament' do
-			lon = 0.6298
-			lat = 51.7923
-			small_radius = IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat, radius: 10
-			large_radius = IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat, radius: 100
-			expect(large_radius.length > small_radius.length).to eq(true)
-		end
-	end
-end
+  describe '.lookup' do
+    it 'returns a list of addresses for a postcode' do
+      addresses = IdealPostcodes::Postcode.lookup 'ID1 1QD'
+      expect(addresses.length).to be > 0
+      addresses.each do |address|
+        expect(is_address(address)).to eq(true)
+        expect(address[:postcode]).to eq('ID1 1QD')
+      end
+    end
+    it 'returns an empty array if postcode does not exist' do
+      addresses = IdealPostcodes::Postcode.lookup 'ID1 KFA'
+      expect(addresses.length).to eq(0)
+    end
+    it 'raises an exception if key has run out of balance' do
+      expect { IdealPostcodes::Postcode.lookup 'ID1 CLIP' }.to raise_error(
+        IdealPostcodes::TokenExhaustedError
+      )
+    end
+    it 'raises an exception if limit has been reached' do
+      expect { IdealPostcodes::Postcode.lookup 'ID1 CHOP' }.to raise_error(
+        IdealPostcodes::LimitReachedError
+      )
+    end
+    it 'raises an exception if invalid key' do
+      IdealPostcodes.api_key = 'foo'
+      expect { IdealPostcodes::Postcode.lookup 'ID1 1QD' }.to raise_error(
+        IdealPostcodes::AuthenticationError
+      )
+    end
+  end
+  describe '.find_by_location' do
+    it 'returns an array of postcodes and locations' do
+      lon = 0.6298
+      lat = 51.7923
+      postcodes =
+        IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat
+      expect(postcodes.length).to be > 0
+      postcodes.each do |postcode|
+        expect(is_postcode_location(postcode)).to eq(true)
+      end
+    end
+    it 'returns an empty array if no results are found' do
+      lon = 0
+      lat = 0
+      postcodes =
+        IdealPostcodes::Postcode.find_by_location longitude: lon, latitude: lat
+      expect(postcodes).to be_a(Array)
+      expect(postcodes.length).to eq(0)
+    end
+    it 'is sensitive to limit parameter' do
+      lon = 0.6298
+      lat = 51.7923
+      limit = 1
+      postcodes =
+        IdealPostcodes::Postcode.find_by_location longitude: lon,
+                                                  latitude: lat,
+                                                  limit: limit
+      expect(postcodes.length).to eq(limit)
+    end
+    it 'is sensitive to radius parament' do
+      lon = 0.6298
+      lat = 51.7923
+      small_radius =
+        IdealPostcodes::Postcode.find_by_location longitude: lon,
+                                                  latitude: lat,
+                                                  radius: 10
+      large_radius =
+        IdealPostcodes::Postcode.find_by_location longitude: lon,
+                                                  latitude: lat,
+                                                  radius: 100
+      expect(large_radius.length > small_radius.length).to eq(true)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -5,64 +5,85 @@ require 'webmock'
 WebMock.enable!
 
 VCR.configure do |c|
-	c.cassette_library_dir = 'spec/vcr_cassettes'
-	c.hook_into :webmock
+  c.cassette_library_dir = 'spec/vcr_cassettes'
+  c.hook_into :webmock
 end
 
 # Configure Ideal Postcodes lib
 require 'ideal_postcodes'
 
 RSpec.configure do |c|
-	c.before(:each) do
+  c.before(:each) do
     IdealPostcodes.base_url = 'https://localhost:1337'
-		IdealPostcodes.api_key = "gandhi"
-		IdealPostcodes.apply_secret nil
+    IdealPostcodes.api_key = 'gandhi'
+    IdealPostcodes.apply_secret nil
   end
 
-	c.around(:each) do |example|
-		VCR.use_cassette(example.metadata[:full_description]) do
-			example.run
-		end
-	end
+  c.around(:each) do |example|
+    VCR.use_cassette(example.metadata[:full_description]) { example.run }
+  end
 end
 
-def contains_attributes attribute_list, target
-	result = true
-	attribute_list.each do |attribute|
-		result = false if target[attribute].nil?
-	end
-	result
+def contains_attributes(attribute_list, target)
+  result = true
+  attribute_list.each { |attribute| result = false if target[attribute].nil? }
+  result
 end
 
 def postcode_location_elements
-	[:postcode, :longitude, :latitude, :northings, :eastings]
+  %i[postcode longitude latitude northings eastings]
 end
 
 def is_postcode_location(postcode)
-	contains_attributes postcode_location_elements, postcode
+  contains_attributes postcode_location_elements, postcode
 end
 
 def address_elements
-	[:postcode, :postcode_inward, :postcode_outward, :post_town, :dependant_locality, 
-		:double_dependant_locality, :thoroughfare, :dependant_thoroughfare, 
-		:building_number, :building_name, :sub_building_name, :po_box, :department_name, 
-		:organisation_name, :udprn, :postcode_type, :su_organisation_indicator, 
-		:delivery_point_suffix, :line_1, :line_2, :line_3, :premise, :county, 
-		:district, :ward, :longitude, :latitude, :eastings, :northings]
+  %i[
+    postcode
+    postcode_inward
+    postcode_outward
+    post_town
+    dependant_locality
+    double_dependant_locality
+    thoroughfare
+    dependant_thoroughfare
+    building_number
+    building_name
+    sub_building_name
+    po_box
+    department_name
+    organisation_name
+    udprn
+    postcode_type
+    su_organisation_indicator
+    delivery_point_suffix
+    line_1
+    line_2
+    line_3
+    premise
+    county
+    district
+    ward
+    longitude
+    latitude
+    eastings
+    northings
+  ]
 end
 
 def is_address(address)
-	contains_attributes address_elements, address
+  contains_attributes address_elements, address
 end
 
 def key_elements
-	[:lookups_remaining, :daily_limit, :individual_limit, :allowed_urls, :notifications]
+  %i[lookups_remaining daily_limit individual_limit allowed_urls notifications]
 end
 
 def is_key(key)
-	contains_attributes key_elements, key
+  contains_attributes key_elements, key
 end
 
 def secret_key
-	"uk_hxp6ouk0rmyXoobVJnehrsQcdvTfb"
-end
+  'uk_hxp6ouk0rmyXoobVJnehrsQcdvTfb'
+end

data/spec/vcr_cassettes/IdealPostcodes_Address_lookup_raises_an_exception_if_invalid_key.yml

@@ -1,42 +1,42 @@
 ---
 http_interactions:
-- request:
-    method: get
-    uri: https://localhost:1337/v1/addresses/0?api_key=foo
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept:
-      - '*/*; q=0.5, application/xml'
-      Accept-Encoding:
-      - gzip, deflate
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 401
-      message: Unauthorized
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      Content-Type:
-      - application/json; charset=utf-8
-      Content-Length:
-      - '135'
-      Etag:
-      - '"-632160061"'
-      Date:
-      - Fri, 12 Dec 2014 17:40:26 GMT
-      Connection:
-      - keep-alive
-    body:
-      encoding: UTF-8
-      string: |-
-        {
-          "code": 4010,
-          "message": "Invalid Key. For more information see http://ideal-postcodes.co.uk/documentation/response-codes#4010"
-        }
-    http_version: 
-  recorded_at: Fri, 12 Dec 2014 17:40:26 GMT
+  - request:
+      method: get
+      uri: https://localhost:1337/v1/addresses/0?api_key=foo
+      body:
+        encoding: US-ASCII
+        string: ""
+      headers:
+        Accept:
+          - "*/*; q=0.5, application/xml"
+        Accept-Encoding:
+          - gzip, deflate
+        User-Agent:
+          - Ruby
+    response:
+      status:
+        code: 401
+        message: Unauthorized
+      headers:
+        Access-Control-Allow-Origin:
+          - "*"
+        Content-Type:
+          - application/json; charset=utf-8
+        Content-Length:
+          - "135"
+        Etag:
+          - '"-632160061"'
+        Date:
+          - Fri, 12 Dec 2014 17:40:26 GMT
+        Connection:
+          - keep-alive
+      body:
+        encoding: UTF-8
+        string: |-
+          {
+            "code": 4010,
+            "message": "Invalid Key. For more information see http://ideal-postcodes.co.uk/documentation/response-codes#4010"
+          }
+      http_version:
+    recorded_at: Fri, 12 Dec 2014 17:40:26 GMT
 recorded_with: VCR 2.9.3

data/spec/vcr_cassettes/IdealPostcodes_Address_lookup_raises_an_exception_if_limit_breached.yml

@@ -1,42 +1,42 @@
 ---
 http_interactions:
-- request:
-    method: get
-    uri: https://localhost:1337/v1/addresses/-3?api_key=gandhi
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept:
-      - '*/*; q=0.5, application/xml'
-      Accept-Encoding:
-      - gzip, deflate
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 402
-      message: Payment Required
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      Content-Type:
-      - application/json; charset=utf-8
-      Content-Length:
-      - '144'
-      Etag:
-      - '"1445167850"'
-      Date:
-      - Fri, 12 Dec 2014 17:40:26 GMT
-      Connection:
-      - keep-alive
-    body:
-      encoding: UTF-8
-      string: |-
-        {
-          "code": 4021,
-          "message": "Lookup Limit Reached. For more information see http://ideal-postcodes.co.uk/documentation/response-codes#4021"
-        }
-    http_version: 
-  recorded_at: Fri, 12 Dec 2014 17:40:26 GMT
+  - request:
+      method: get
+      uri: https://localhost:1337/v1/addresses/-3?api_key=gandhi
+      body:
+        encoding: US-ASCII
+        string: ""
+      headers:
+        Accept:
+          - "*/*; q=0.5, application/xml"
+        Accept-Encoding:
+          - gzip, deflate
+        User-Agent:
+          - Ruby
+    response:
+      status:
+        code: 402
+        message: Payment Required
+      headers:
+        Access-Control-Allow-Origin:
+          - "*"
+        Content-Type:
+          - application/json; charset=utf-8
+        Content-Length:
+          - "144"
+        Etag:
+          - '"1445167850"'
+        Date:
+          - Fri, 12 Dec 2014 17:40:26 GMT
+        Connection:
+          - keep-alive
+      body:
+        encoding: UTF-8
+        string: |-
+          {
+            "code": 4021,
+            "message": "Lookup Limit Reached. For more information see http://ideal-postcodes.co.uk/documentation/response-codes#4021"
+          }
+      http_version:
+    recorded_at: Fri, 12 Dec 2014 17:40:26 GMT
 recorded_with: VCR 2.9.3

data/spec/vcr_cassettes/IdealPostcodes_Address_lookup_raises_an_exception_if_no_lookups_remaining.yml

@@ -1,42 +1,42 @@
 ---
 http_interactions:
-- request:
-    method: get
-    uri: https://localhost:1337/v1/addresses/-2?api_key=gandhi
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      Accept:
-      - '*/*; q=0.5, application/xml'
-      Accept-Encoding:
-      - gzip, deflate
-      User-Agent:
-      - Ruby
-  response:
-    status:
-      code: 402
-      message: Payment Required
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      Content-Type:
-      - application/json; charset=utf-8
-      Content-Length:
-      - '146'
-      Etag:
-      - '"1304241290"'
-      Date:
-      - Fri, 12 Dec 2014 17:40:26 GMT
-      Connection:
-      - keep-alive
-    body:
-      encoding: UTF-8
-      string: |-
-        {
-          "code": 4020,
-          "message": "Token balance depleted. For more information see http://ideal-postcodes.co.uk/documentation/response-codes#4020"
-        }
-    http_version: 
-  recorded_at: Fri, 12 Dec 2014 17:40:26 GMT
+  - request:
+      method: get
+      uri: https://localhost:1337/v1/addresses/-2?api_key=gandhi
+      body:
+        encoding: US-ASCII
+        string: ""
+      headers:
+        Accept:
+          - "*/*; q=0.5, application/xml"
+        Accept-Encoding:
+          - gzip, deflate
+        User-Agent:
+          - Ruby
+    response:
+      status:
+        code: 402
+        message: Payment Required
+      headers:
+        Access-Control-Allow-Origin:
+          - "*"
+        Content-Type:
+          - application/json; charset=utf-8
+        Content-Length:
+          - "146"
+        Etag:
+          - '"1304241290"'
+        Date:
+          - Fri, 12 Dec 2014 17:40:26 GMT
+        Connection:
+          - keep-alive
+      body:
+        encoding: UTF-8
+        string: |-
+          {
+            "code": 4020,
+            "message": "Token balance depleted. For more information see http://ideal-postcodes.co.uk/documentation/response-codes#4020"
+          }
+      http_version:
+    recorded_at: Fri, 12 Dec 2014 17:40:26 GMT
 recorded_with: VCR 2.9.3